Fsharp Slides

8/10/2019 Fsharp Slides

1/15

1

www.itu.dk 1

Programming language seminar 2011

The F# language

Peter SestoftWednesday 2011-08-31

www.itu.dk 2

Course plan

Four cycles, each containing a mini-project: F#

Types and type inference

Scala and Scala actors

Programming language technology inside a high-performance spreadsheet implementation, more F#

Final course report, individual, 10 pages

Either continuation of a mini-project Or some other topic/language/... that you find

interesting and want to explore

Wednesdays (0900-1200) lectures or consultations, see homepage

Homepagehttp://www.itu.dk/courses/SPLG/E2011/


2/15

2

www.itu.dk 3

Sources Hansen+Rischel: Functional programming with F#

(DTU, draft 2011) PDF distributed onlyto this course; do not redistribute

Sestoft: Programming Language Concepts forSoftware Developers (PLCSD), ITU August 2011

Complete PDF on course homepage

Materials on Scala and Scala actors

Sestoft: Spreadsheet technology(ITU, later 2011)

Homepage http://www.itu.dk/courses/SPLG/E2011/ Schedule

Reading materials

Exercises

Occasional example programs from lectures

Why F# and Scala


3/15

3

www.itu.dk

F# Developed by Don Syme at Microsoft

Research, Cambridge UK

A functional language in the ML family

With many additions and innovations

Dimension types

Object-oriented features

Workflows (asynchronous computing)

Runs on the .NET platform (like C#, VB.NET)

For Windows, Linux and MacOS

Included in Visual Studio 2010

Or from http://msdn.microsoft.com/en-us/fsharpand use Mono 2.10 or .NET redistributable

5

F# values, declarations and types

Interactive system top-level fsi

Strongly typed, types are inferred

Immutability: letis bindingnot assignment

let res = 3+4;;

let y = sqrt 2.0;;

let large = 10 < res;;

y > 0.0 && 1.0/y > 7.0;;

if 3 < 4 then 117 else 118;;

let rektor = "Mads " + "Tofte";;

Expression

Declaration


4/15

4

www.itu.dk 7

F# function definitions

A function that finds the average of twofloating-point numbers?

let circleArea r = System.Math.PI * r * r;;

let mul2 x = 2.0 * x;;

Functionname

Parameter

> circleArea 10.0;;val it : float = 314.1592654

www.itu.dk 8

F# recursive function definitions

Same in Java/C#/C/C++:

let rec fac (n : int) : int =if n=0 then 1else n * fac(n-1);;

int fac(int n) {if (n==0)return 1;

elsereturn n * fac(n-1);

}


5/15

5

www.itu.dk 9

F# type constraints

What if we give a wrong type constraint?

let isLarge (x : float) : bool = 10.0 < x;;val isLarge : float -> bool

let isLarge x = 10 < x;;val isLarge : int -> bool

www.itu.dk 10

F# pattern matching

A pattern can be a variable a constant

a wildcard (_)

a constructor application x :: xr

a list []or [x]or x::y::xr

a tuple (x, y)or (2, 29)or ([], x::xr)

let rec fac n =match n with

| 0 -> 1| _ -> n * fac(n-1);;


6/15

6

www.itu.dk 11

F# pairs and tupleslet p = (2, 3);;let w = (2, true, 3.4, "blah");;

let add (x, y) = x + y;;

let noon = (12, 0);;let talk = (15, 15);;

let earlier ((h1, m1), (h2, m2)) =h1


7/15

7

www.itu.dk 13

List append (@)

F# data (lists, pairs, ) are immutable

This makes list sharing unobservable

let x1 = [7; 9; 13];;let x3 = [47; 11];;

let x1x3 = x1 @ x3;;

Result is[7; 9; 13; 47; 11]

9

11

13

47

7

9 137

x1

x3

x1x3

www.itu.dk 14

F# defining functions on lists

How compute the length of a list? How compute the average of a list?

let rec sum xs =match xs with

| [] -> 0| x::xr -> x + sum xr;;


8/15

8

www.itu.dk 15

F# record types and records

A record type for course information: title,teacher, semester?

type phonerec ={ name : string; phone : int };;

let x ={ name = "Kasper"; phone = 5170 };;

x.name;;x.phone;;

www.itu.dk 16

F# exceptions: raise and catch

exception IllegalHour;;let mins h =

if h < 0 || h > 23 then raise IllegalHourelse h * 60;;

try (mins 25)with IllegalHour -> -1;;


9/15

9

www.itu.dk 17

failwith raises the Failure exceptionlet mins h =

if h < 0 || h > 23 then failwith "Illegal hour"else h * 60;;

let mins h =if h < 0 || h > 23 then

failwithf "Illegal hour, h=%d" helse

h * 60;;

mins 25;;[...] FailureException: Illegal hour, h=25

Formattedfailwith

Like Cprintf

www.itu.dk 18

F# algebraic datatypes

Algebraic datatype, discriminated union

A person is either a teacher or a student:

type person =| Student of string| Teacher of string * int;;

let people = [Student "Niels"; Teacher("Peter", 5083)];;

let getphone person =match person with

| Teacher(name, phone) -> phone| Student name -> failwith "no phone";;

A type to represent weekdays?

How would you do person/Student/Teacher in Java/C#?


10/15

10

www.itu.dk 19

F# curried functions

Function application is left associative:

addc x y means

(addc x) y The function type arrow is right associative:

int -> int -> int means int -> (int -> int)

What would (int -> int) -> int mean?

let addp (x, y) = x + y;;let res1 = addp(17, 25);;

let addc x y = x + y;;let res2 = addc 17 25;;

Type?

Type?

www.itu.dk 20

Anonymous functions in F#

A higher-order function takes anotherfunction as argument

let rec map f xs =match xs with

| [] -> []| x::xr -> f x :: map f xr

(a->b) -> (a list -> b list)

let mul2 x = 2.0 * x;;map mul2 [4.0; 5.0; 89.0];; [8.0; 10.0; 178.0]

Anonymous functionsmap (fun x -> 2.0 * x) [4.0; 5.0; 89.0]

map (fun x -> x > 10.0) [4.0; 5.0; 89.0]

[8.0; 10.0; 178.0]

[false; false; true]


11/15

11

21

delegate R Func()delegate R Func(A1 x1)delegate R Func(A1 x1, A2 x2)

Higher-order functions in C# C# delegate (function) types

Anonymous function/method expressions

(int x) => x>10x => x>10x => x*x

C# 3.0

fun (x:int) -> x>10fun x -> x>10fun x -> x*x

F#

unit -> intbool -> intint * bool -> string

FuncFuncFunc

C# 3.0F#

www.itu.dk 22

F# polymorphic functions

Same as a generic method in Java or C#

let rec len xs =match xs with

| [] -> 0| x::xr -> 1 + len xr;;

val len : 'a list -> int

The functiondoesnt look at

the list elements

so the functionis polymorphic

static int Count(IEnumerable xs) { ... }

len [7; 9; 13]len [true; true; false; true]len ["foo"; "bar"]len [("Peter", 47)]

and works in

any type of list


12/15

12

www.itu.dk 23

F# polymorphic types

Same as a generic type in Java or C#:

type 'a tree =| Lf| Br of 'a * 'a tree * 'a tree

Br(42, Lf, Lf)Br("quoi?", Lf, Lf)Br(("Peter", 47), Lf, Lf)

The datatype hassame structure

regardless of nodevalue type

What typeinstances here?

class ArrayList { ... }interface IEnumerable { ... }struct Pair { ... }delegate R Func(A x);

www.itu.dk 24

Polymorphic functionson polymorphic types

Return the trees node values in pre-order

first root, then left subtree, then right subtree

Works on any type of tree

What is the type of this function?

let rec preorder1 t =match t with| Lf -> []| Br(v, t1, t2) -> v :: preorder1 t1 @ preorder1 t2


13/15

13

www.itu.dk

Accumulating parameters The append (@) operation may be slow

A faster version of preorder, no append!

let rec preo t acc =match t with| Lf -> acc| Br(v, t1, t2) -> v :: preo t1 (preo t2 acc);;

let preorder2 t = preo t [];;

This works becausepreo t acc = preorder1 t @ acc

Sopreorder2 t = preo t [] = preorder1 t

Accumulatingparameter

O(n) versus O(n2)

Can be 1000 x faster

Try #time;;in F#

www.itu.dk

Uniform iteration over a list

Generalizing 0/1 to e, and +/* to f:

let rec sum xs =match xs with

| [] -> 0| x::xr -> x + sum xr

let rec prod xs =match xs with

| [] -> 1| x::xr -> x * prod xr

let rec foldr f xs e =match xs with

| [] -> e| x::xr -> f x (foldr f xr e)

The foldr function replaces :: by f, and [] by e:foldr !(x1::x2::::xn::[]) e = x1!(x2!(... !(xn!e) ))

('a -> 'b -> 'b) ->'a list -> 'b -> 'b

int list -> int

List.foldBack in F#


14/15

14

www.itu.dk 27

Many functions definable using foldrlen xs = foldr (fun _ res -> 1+res) xs 0

sum xs = foldr (fun x res -> x+res) xs 0

prod xs = foldr (fun x res -> x*res) xs 1

map g xs = foldr (fun x res -> g x :: res) xs []

listconcat xss = foldr (fun xs res -> xs @ res) xss []

strconcat ss = foldr (fun s res -> s ^ res) ss "

filter p xs = list of those x in xs for which p x is true

forall p xs = p x is true for all x in xs

exists p xs = p x is true for some x in xs

www.itu.dk 28

Composing functions, pipe

Given list xs, throw away small numbers, square theremaining numbers, and compute their sum:

sum (map (fun x -> x*x) (filter (fun x -> x>10) xs))

x |> f = f x

Somewhat difficult to read: inside-out

Idea: Define infix higher-order function |>

Now the list operations combine naturally:

xs |> filter (fun x -> x>10) |> map (fun x -> x*x) |> sum


15/15

15

www.itu.dk

F# mutable references A reference is a cell that can be updated

let r = ref 177!r(r := !r+1; !r)!r

Useful for generation of new names etc:

let nextlab = ref -1;;let newLabel () = (nextlab := 1 + !nextlab;

"L" + string (!nextlab));;newLabel();;newLabel();;newLabel();;

Create int reference

Assign to reference

Dereference

www.itu.dk

Reading and exercises

Install F# and experiment with it

Either Visual Studio 2010 (a monster, availablevia your MSDNAA account)

Or using Mono from www.mono-project.com

Read Hansen & Rischel

Chapters 1 to 5

There are exercises in Hansen & Rischel

Do them as needed

Or do the first steps of miniproject 1

30

Fsharp Slides

Documents

Transcript of Fsharp Slides