Concepts of programming languages - F# · F# Tim Zoet, Zino Onomiwo, Martijn Boom, Rik van Toor...

[Faculty of ScienceInformation and Computing

Sciences]1

Concepts of programming languagesF#

Tim Zoet, Zino Onomiwo, Martijn Boom, Rik van Toor


Sciences]2

Background

▶ Don Syme▶ Microsoft Research▶ Recent development by the F# Software Foundation▶ Microsoft develops the Visual F# tools


Sciences]3

What is F#

▶ A first-class member of the .NET Framework.▶ Strongly related to ML and OCaml.▶ A hybrid language▶ Integration within Visual Studio


Sciences]4

Programming in F#

Hello World

let a_string = "World"printfn "Hello %s" a_string


Sciences]5

Types and variables

type name = stringlet author: name = "infinite monkey"

What features regarding types are supported in F#?


Sciences]6

Tuples, structures and more.

Tuples:

type tuple = int * stringlet tuple = (1, “hi!”) // Comma separated

Records

type Person = {Name:string; Age:int; Status:string} // named fields, semicolon separatedlet celebrity= {Name=”Gordon”, Age=49, Status=”single”}


Sciences]7


Union

type Person =| CatPerson of string| DogPerson of string

let martijn = DogPerson “Martijn”


Sciences]8


Recursive structures and unions:

type 'a union = A 'a | B 'atype 'a tree =

|EmptyTree| Node of 'a * 'a tree * 'a tree


Sciences]9


Structures:

type Cat = structval Name: name;val Fur: colorval Env: environmentnew (n, f, e)

= {Name = n; Fur = f; Env = e}end

let cat: Cat = new Cat("Ottoman", RED, BLOCKCHAIN)


Sciences]10

Lists and arrays

Arrays

Fixed size and mutable

let arr = [|1; 2; 3; 4; 5|]let arr2 = [|1.0; 2; 3|] // Gives an errorlet arr3 = [|for i in 1 .. 100 -> i * (i+1)|]printfn “%d” arr.[0] // prints 2printfn “%A” array // print [1; 2; 3; 4; 5]


Sciences]11

Lists and arrays

Listssingly linked list and immutable

let lissy = [1; 2; 3]let lissy2= 1::[2 … 8999] @ [1]let lissy3= [for i in 1 .. 100 -> i * (i+1)]

let rec sum list =match list with| head :: tail -> head + sum tail| [] -> 0


Sciences]12

Functions

let add x y = x + ylet sumOfSquares n =[1..n] |> List.map square |> List.sumsumOfSquares 100let adderGenerator = fun x -> (fun y -> x + y)


Sciences]13

Classes

type Exam(student, subject, grade) =member this.Student = studentmember this.Subject = subjectmember this.Grade = grade// public member

let stressLevel = 100 //private member

new Exam(“Socrates”, “Philosophy for dummies”, 10)


Sciences]14

Pattern matching

match x with| case1 -> …| case2 -> …| _ -> …


Sciences]15

let patternMatcher input =match input with| “a” -> printfn “Case 1”| “b” -> printfn “Case 2”| _ -> printfn “Default”

patternMatcher “a”patternMatcher “b”patternMatcher “c”


Sciences]16

let listSummary list =match list with| [] -> printfn "empty array"| [x] -> printfn "one element: %s" x| [x;y] -> printfn "two elements”| _ -> printfn "multiple elements"


Sciences]17

Async

Ruin code in parallel

let motivationLevel (lvl, target) = async {printfn "Motivating %s till %i \%" target lvldo! Async.Sleep percentageprintfn "%s is %i \% motivated" target lvl}[(101, “Tim”), (65, “Rik”)]|> List.map motivationLevel|> Async.Parallel|> Async.RunSynchronously


Sciences]18

[<Measure>] type cm[<Measure>] type meter

let cmPerMeter = 10<cm/meter>let distanceToHomeCm = 100<cm>let distanceToHomeM = distanceToHomeCm * cmPerMeterlet otherConvert v: float<_> =match v with| :? float<cm> -> v * cmPerMeter| :? float<meter> -> v<meter>


Sciences]19

Type inference

▶ Using amas-Milner’s Algorithm▶ Look at the literals▶ Look at the functions and other values something interacts

with▶ Look at any explicit type constraints▶ If there are no constraints anywhere, automatically

generalize to generic types


Sciences]20

Relation to other languages


Sciences]21

Compared to C#

▶ Concise

public static IEnumerable<T> QuickSort<T>(this IEnumerable<T> values) where T: IComparable{

if (values == null || !values.Any()) return new List<T>();

var pivot = values.First();var rest = values.Skip(1);

var smallerElements = rest.Where(i => i.CompareTo(pivot) < 0).QuickSort();var largerElements = rest.Where(i => i.CompareTo(pivot) >= 0).QuickSort();

return smallerElements.Concat(new List<T> { pivot }).Concat(largerElements);}


Sciences]22

let rec quicksort = function| [] -> []| pivot::rest ->

let smaller,larger =List.partition ((>=) pivot) rest

List.concat[quicksort smaller; [pivot]; quicksort larger]

▶ Little coding noise▶ Pattern matching▶ Functional List module


Sciences]23

Type inference

let AStringFunction ="It is implied I return a string"

let AStringFunction :string ="It is made explicit I return a string"

string AnotherStringFunction(){return "I'm a string function as well";}


Sciences]24

Domain-driven design

type StreetAddress = {Line1:string; Line2:string;Line3:string }

type ZipCode = ZipCode of stringtype StateAbbrev = StateAbbrev of stringtype ZipAndState = {State:StateAbbrev; Zip:ZipCode }type USAddress = {Street:StreetAddress;

Region:ZipAndState}type UKPostCode = PostCode of stringtype UKAddress = {Street:StreetAddress;

Region:UKPostCode}


Sciences]25

Domain-driven design

type InternationalAddress = {Street:StreetAddress; Region:string;

CountryName:string}type Address = USAddress

| UKAddress| InternationalAddress


Sciences]26

Interoperability with C#

namespace interoperability.fsharp

type Beverage (brand:string, volume:int) =member this.Brand = brandmember this.Volume = volume


Sciences]27

using interoperability.fsharp;

namespace interoperability.csharp{class Program{

static void Main(string[] args){

//from record to classBeverage coke = new Beverage("Coca Cola", 330);Console.WriteLine(coke.name + “ “ + coke.Volume);

}}}


Sciences]28




//from record to classBeverage coke = new Beverage("Coca Cola", 330);Console.WriteLine(coke.name + “ “ + coke.Volume);

}}}

▶ output = “Coca Cola 330”


Sciences]29



module BeverageTasks =let drink (x:Beverage) = Beverage(x.Brand, 0)


Sciences]30




//from record to classBeverage coke = new Beverage("Coca Cola", 330);//from module to static classcoke = BeverageTasks.drink(coke)Console.WriteLine(coke.name + “ “ + coke.Volume);

}}}


Sciences]31




//from record to classBeverage coke = new Beverage("Coca Cola", 330);//from module to static classcoke = BeverageTasks.drink(coke);Console.WriteLine(coke.name + “ “ + coke.Volume);

}}}

output = “Coca Cola 0”


Sciences]32



module BeverageTasks =let drink (x:Beverage) = Beverage(x.Brand, 0)let mutable message

= "Wasn't I supposed to be functional?"


Sciences]33




//from record to classBeverage coke = new Beverage("Coca Cola", 330);Console.WriteLine(BeverageTasks.message);BeverageTasks.message = "Not anymore!";Console.WriteLine(BeverageTasks.message);

}}}


Sciences]34




//from record to classBeverage coke = new Beverage("Coca Cola", 330);Console.WriteLine(BeverageTasks.message);BeverageTasks.message = "Not anymore!";Console.WriteLine(BeverageTasks.message);

}}}

▶ “Wasn’t I supposed to be functional?”▶ “Not anymore!”


Sciences]35

type Taste =| Sweet = 'a'| Sour = 'b'| Bitter = 'c'| Salty = 'd'

Taste cokeTaste = Taste.Sweet;


Sciences]36

type Taste =| Sweet = 'a'| Sour = 'b'| Bitter = 'c'| Salty = 'd'

Taste cokeTaste = Taste.Sweet;

▶ error = ‘Taste.Sweet’ is not supported by the language


Sciences]37

Relation to Haskell

▶ Both are functional languages▶ Both have cool logos

▶ Similar way of thinking while coding


Sciences]38

Relation to Haskell

F#

▶ Functional first

Haskell

▶ Purely functional


Sciences]39

Polymorphism

F#

▶ Does not really exist

Haskell

▶ Exists


Sciences]40

Polymorphism

Haskell (in GHCi):

> let square x = x * x> square 24> square 2.04.0


Sciences]41

Polymorphism

F# (in fsharpi):

> let square x = x * x;;> square 2;;val it : int = 4> square 2.0;;error FS0001: This expression was expected tohave type int

Caused by Type Inference.


Sciences]42

Polymorphism

To override:

> let inline square x = x * x;;> square 2;;val it : int = 4> square 2.0;;val it : float = 4.0


Sciences]43

Polymorphism - More difficult

In Haskell:

class Showable a whereshw :: a -> String

data A = A Stringdata B = B Int

instance Showable A whereshw (A s) = s

instance Showable B whereshw (B i) = show i


Sciences]44


In F#:

type A = { thing: int }with static member show a = sprintf "%A" atype B = { label: string }with static member show b = sprintf "%A" b

let inline show (x:^t) =(^t: (static member show: ^t -> string) (x))

This is called statically resolved type constraints


Sciences]45


An alternative in F#:

type A = { thing: int }type B = { label: string }

type ThingThatShows =static member show(x:A) = sprintf "%A" xstatic member show(x:B) = sprintf "%A" x

This is called static member overloading


Sciences]46

Currying

Works the same way in F# and Haskell.

let f a b = something

is internally converted to

let f a =let g b = somethingg


Sciences]47

Currying

This also means that the type signature

a -> b -> c

is equal to

a -> (b -> c)

Just like it would be in Haskell.


Sciences]48

Partial application

Consider f :: int -> int -> int.

Because of the currying mechanism, f 2 will be of type int ->int.

Partial applications works the same way in F# and Haskell.


Sciences]49

Function associativity

x y z is equal to (x y) z.

Just like in Haskell, function application is left associative.

Operators exist to help:

x <| y z is equal to x (y z), limiting the number ofparentheses.

The same operator but inverted exists as well:

x y |> z is equal to z (x y).


Sciences]50

Evaluation

Haskell uses lazy evaluation.

F# uses eager evaluation by default, unless explicitly specifiedotherwise.

Example:

let always5 x = 5


Sciences]51

Evaluation

Haskell:

-- Will just return 5always5 $ map sqrt [1.0..1000000000.0]

F#:

//Will take a long timealways5 <| List.map sqrt [1.0..1000000000.0]

//Will just return 5always5 <| lazy(List.map sqrt [1.0..1000000000.0])


Sciences]52

Syntax

F#:

▶ A little more verbose than Haskell▶ More keywords than Haskell

Haskell:

▶ Amazing▶ The best


Sciences]53

Syntax - examples

▶ let let let let let let let let let let let let let.▶ You will type let a lot in F#.


Sciences]54

Syntax - examples

F#

let rec sum list =match list with| head :: tail -> head + sum tail| [] -> 0

Haskell

sum [] = 0sum (head:tail) = head + sum tail

▶ Explicit rec


Sciences]55

Type providers

‘Information-rich programming’


Sciences]56

Making programming as easy as possible.


Sciences]57

Coincidentally the subject of our research project.


Sciences]58

▶ Generate types and add them to your project based onsome source containing type definitions.

▶ Type checking.▶ Auto-completion.▶ Integrated connection handling.


Sciences]59

Improvement on:

▶ Manual implementation▶ Code generation▶ (Runtime generation)


Sciences]60

Manual implementation

▶ Write F# type for every type in your information space.


Sciences]61

Manual implementation

▶ Updates of information space? Manual work…▶ Not doable in real world applications with thousands of

types.


Sciences]62

Code generation

▶ Generate F# types from e.g. a file containing typedefinitions.


Sciences]63

Code generation

▶ Rerun when information space changes.


Sciences]64

Example CSV

name age lengthAlice 42 1.69Bob 24 1.78Eve 32 1.75… … …


Sciences]65

type UserFile = CsvProvider<"someFile.csv">let userFileInstance =

UserFile.Load("sameOrMaybeAnotherFile.csv")print userFileInstance.firstRow.name


Sciences]66

type UserFile = CsvProvider<"someFile.csv">

Generate types from some file containing (sample) data.


Sciences]67

let userFileInstance =UserFile.Load("sameOrMaybeAnotherFile.csv")

print userFileInstance.firstRow.name

Create instance and access data. ‘Normal code’.


Sciences]68

What about databases?

type DatabaseSource =DatabaseProvider<"www.mydatabase.com/types">

let databaseConnection =DatabaseSource.Connect("www.mydatabase.com")

// ...perform queries on databaseConnection


Sciences]69

Great… so?

▶ Type checking.▶ Auto-completion.▶ Connections/files etc.▶ Extend types.

We could already do all these things.


Sciences]70

But… it’s all in one place.


Sciences]71

More: regular expressions.

type T = RegexTyped< @"(?<AreaCode>^\d{3})-(?<PhoneNumber>\d{3}-\d{4}$)">

let reg = T()let result = T.IsMatch("425-555-2345")

Limitation: string has to be known at compile-time.


Sciences]72

How do you actually write a type provider?

[<TypeProvider>]type CsvProvider(config: TypeProviderConfig) as this =//


Sciences]73

1. Add static parameters to the type provider.2. Call ProvidedTypeDefinition to provide the base type.3. Add methods such as Load and members such as Rows to

the base type.4. Open the sample file.5. Infer the type from each column and add these types.


Sciences]74

Biggest limitation.

Static parameters can only be primitive types.


Sciences]75

Thank you for your attention

Please feel free to ask any questions.

Date post:	03-Oct-2020
Category:	Documents
Upload:	others
View:	1 times
Download:	0 times

Concepts of programming languages - F# · F# Tim Zoet, Zino Onomiwo, Martijn Boom, Rik van Toor...

Documents