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

transcript

[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

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

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

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

▶ Functional first

Haskell

▶ Purely functional

Sciences]39

Polymorphism

▶ 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]

//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

▶ 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

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.

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

Documents