Overview
- A tour of the language
- Walkthrough of a practical example
- Q&A
What I like about F#
- Can be used for a lot of different scenarios: Console applications, cross platform native UI apps, scripts, web applications, web UIs, data science notebooks, ...
- ADTs and type inference lead to high productivity and no slowdown of development speed over time
- Defaults to immutability, functions + data
- But supports mutability, object oriented features, ...
- Great community
Values
and type inferrence
let aBoolean = true
let someInt = 5
let someFloat = 4.3
let someString = "This is a string value"
let ( someOtherInt : int ) = 42
let tuple = (4, "a string value")
let listA = [ 1; 2; 3 ]
let listB : List<int> =
[ 1
2
]
let listC = 1 :: [ 2; 3]
let someArray : Array<string> =
[| "This"; "is"; "an"; "array" |]
let secondElement = someArray.[1]
Comparing syntax
(Javascript)
function addNumbers(first, second) {
return first + second;
}
addNumbers(3, 4);
Comparing syntax
(F#)
let addNumbers(first, second) =
first + second
addNumbers(3, 4)
Comparing syntax
(F#)
let addNumbers (first, second) =
first + second
addNumbers(3, 4)
Yes, F# is white space sensitive
Comparing syntax
(F#)
let addNumbers (first : int, second : int) : int =
first + second
addNumbers(3, 4)
Currying &
partial application
let addNumbers (first : int) (second : int) : int =
first + second
addNumbers 2 4
// 6
let addFive =
addNumbers 5
addFive 10
// 15
Records
type Person =
{ FirstName : string
LastName : string
YearOfBirth : int }
let batman =
{ FirstName = "Bruce"
LastName = "Wayne"
YearOfBirth = 1939
}
let printPerson (person : Person) =
printfn "%s %s (Born %d)" person.FirstName
person.LastName person.YearOfBirth
printPerson batman
// Bruce Wayne (Born 1939)
let theDarkKnight =
{ batman with YearOfBirth = 1986 }
Discriminated Unions
(Sum types)
type Direction =
| Up
| Right
| Left
| Down
let printDirection (dir : Direction) =
match dir with
| Up -> printfn "Up"
| Right -> printfn "Right"
| Left -> printfn "Left"
| Down -> printfn "Down"
printDirection Up
Discriminated Unions
(Sum types)
type Status<'successType> =
| Pending
| Running of current : int * total : int
| Success of 'successType
| Error of string
let printStatus status =
match status with
| Pending -> printfn "Pending"
| Running(0, n) -> printfn "Starting with first item of %d" n
| Running(i, n) -> printfn "Processing %d of %d" i n
| Success success ->
printfn "Succesfully completed, result is %O" success
| Error msg -> printfn "Error: %s" msg
printStatus (Running(2, 4))
// Processing 2 of 4
printStatus (Success 42)
// Succesfully completed, result is 42
Optional values and errors
// Defined in the standard library
type Option<'a> =
| None
| Some of 'a
type Result<'success, 'error> =
| Ok of 'success
| Error of 'error
let safeDivision (x : float) (y : float) : Option<float> =
match y with
| 0.0 -> None
| nonzero -> Some (x / nonzero)
let safeDivision2 (x : float) (y : float) : Result<float, string> =
match y with
| 0.0 -> Error "Division by zero"
| nonzero -> Ok (x / nonzero)
let result = safeDivsision2 1.0 0.0
match result with
| Ok r -> printfn "Result is %f" r
| Error e -> printfn "Error: %s" e
Handling Errors
Exceptions
let divide (x : float) (y : float) : float =
x / y
let doCalculation (x : float) (y : float) : float =
try
divide x y
with
| :? DivideByZeroException as ex -> printfn "y was 0!"
Mutation
let mutable i = 0
while i < 4 do
printfn "i is now %d" i
i <- i + 1
let processInstance = new System.Diagnostics.Process()
processInstance.StartInfo.FileName <- "echo"
processInstance.StartInfo.CreateNoWindow <- true
processInstance.Start();
Now for some less common features
Many options are annoying
let createPerson (context : HttpContext) : Option<Person> =
let firstNameOption = context.TryGetQueryParam "firstname"
let lastNameOption = context.TryGetQueryParam "lastname"
let yearBornOption = context.TryGetQueryParam "yearBorn"
match firstNameOption, lastNameOption, yearBornOption with
| Some firstName, Some lastName, Some yearBorn ->
Some { FirstName = firstName
LastName = lastName
YearOfBirth = yearBorn }
| _ -> None
Wouldn't it be nice if
A library could provide blocks that define new semantics for sequencing expressions?
E.g. if any of these expressions gives None, return None
Computation Expressions
let createPerson (context : HttpContext) : Option<Person> =
option {
let! (firstName : string) = context.TryGetQueryParam "firstname"
let! (lastName : string) = context.TryGetQueryParam "lastname"
let! (yearBorn : string) = context.TryGetQueryParam "yearBorn"
return { FirstName = firstName
LastName = lastName
YearOfBirth = yearBorn }
}
Computation Expressions
let retrieveFromRemoteStore key : Async<string> =
// ommited
let createPerson (context : HttpContext) : Async<Person> =
async {
let! firstName = retrieveFromRemoteStore "firstname"
let! lastName = retrieveFromRemoteStore "lastname"
let! yearBorn = retrieveFromRemoteStore "yearBorn"
return { FirstName = firstName
LastName = lastName
YearOfBirth = yearBorn }
}
Computation Expressions
let aSequence : seq<int> =
seq {
1 .. 5
}
let bSequence : seq<int> =
seq {
yield 0
yield! aSequence
yield 23
}
Units of Measure
[<Measure>] type m
[<Measure>] type sec
[<Measure>] type kg
let distance =
1.0<m> // float<m>
let time =
2.0<sec> // float<sec>
let speed =
distance/time // float<m/sec>
let acceleration =
speed/time // float<m/sec^2>
let mass =
5.0<kg> // float<kg>
let force =
mass * speed/time // float<kg*m/sec^2>
Type Providers
// berlin-weather.csv
// Date, Minimum Temperature, Maximum Temperature
// 2020-01-01, -3.4, 2.5
// ...
type WeatherHistory = CsvProvider<"berlin-weather.csv">
// type WeatherHistoryRow =
// { Date : System.DateTime
// ``Minimum Temperature``: float
// ``Maximum Temperature``: float }
let berlinHistory = WeatherHistory.Load("berlin-weather.csv")
for row in berlinHistory.Rows do
printfn "%O: minimum was %f" row.Date row.``Minimum Temperature``
the SAFE Stack
F# on the back end and the front end
A template that sets up:
- An HTTP application web server using ASP.NET Core
- A Fable (F# → Javascript) example SPA using React for rendering and Elmish for state management
- Bulma as the default styling framework
- A shared projects with types and functions that can be used on the server and the client
- A Webpack setup for hot reloading during development and bundling for production
The server
/src/Server
"/api/getTodos" => Unit -> List<Todo>
"/api/addTodo" => Todo -> Todo
can also serve files
/index.html -> ./assets/index.html
The SPA
/src/Client
type Model =
{ Todos: Todo list
Input: string}
type Msg =
| GetTodos of Todo list
| SetInput of string
| AddTodo
| AddedTodo of Todo
let init(): Model * Cmd<Msg> = // ...
let update
(msg : Msg)
(model: Model)
: Model * Cmd<Msg> = // ...
let view
(model : Model)
(dispatch : Msg -> unit)
: ReactElement = //..
Shared code
/src/shared
type Todo =
{ Id : Guid
Description : string }
type ITodosApi =
{ getTodos : unit -> Async<Todo list>
addTodo : Todo -> Async<Todo> }
Demo time
3 years of using F#
The positives
- Same language on Frontend, Backend and even in make files is great
- Algebraic Data Types are great
- Big ecosystems (.NET and Javascript) are very useful
- Asp.Net core is fast and works nicely with linux docker containers
3 years of using F#
The negatives
- Documentation of F#/Fable libraries sometimes lacking
- Community is a lot smaller than some other languages
- No great meta-programming solutions
Where to find more
Currying &
partial application
// defined in the standard library
module List =
let rec map (mapFn : 'a -> 'b) (list : List<'a>) : List<'b> =
match list with
| [] -> []
| [ item ] -> [ mapFn item ]
| item :: rest -> mapFn item :: map mapFn rest
List.map (fun x -> sprintf "%d" x) [ 1; 2; 3]
[ 1; 2; 3]
|> List.map (fun x -> sprintf "%d" x)
Computation Expressions
let optionBind (f : 'a -> Option<'b>) (value : Option<'a>) =
match value with
| None -> None
| Some v -> f v
type OptionBuilder() =
member this.Return(x) =
Some x
member this.Bind(m, f) =
Option.bind f m
let option = OptionBuilder()
Computation Expressions
let createPerson (context : HttpContext) : Option<Person> =
option {
let! firstName = context.TryGetQueryParam "firstname"
let! lastName = context.TryGetQueryParam "lastname"
let! yearBorn = context.TryGetQueryParam "yearBorn"
return { FirstName = firstName
LastName = lastName
YearOfBirth = yearBorn }
}
let createPerson (context : HttpContext) : Option<Person> =
context.TryGetQueryParam "firstname"
|> optionBind
(fun firstName ->
context.TryGetQueryParam "lastname"
|> optionBind
(fun lastName ->
context.TryGetQueryParam "yearOfBirth"
|> optionBind
(fun yearBorn ->
{ FirstName = firstName
LastName = lastName
YearOfBirth = YearOfBirth
})
)
)
Why I like F#
By Daniel Bachler
Why I like F#
- 963