• F# fundamentals
• Scripts and applications
• Functional concepts

• 5 different modules
• Each module focuses on different topics (but might borrow from each other)
• Theory between each set of exercises
• Exercises that covers most of the theory

• Flight ticketing application
• Use cases:
  • Add user
  • List users
  • Reserve ticket
  • Ticket should be automatically upgraded for gold members
  • Point for distance and spending
  • Point might give you gold member status
  • List tickets for customer

• REPL (Read Evaluate Print Loop)
  • End line with ;; to mark the end of the input
  • C:\Program Files (x86)\Microsoft SDKs\F#\4.1\Framework\v4.0\fsi.exe (tip: add to path)
• Visual Studio
  • Alt+Enter - send selection to REPL/Interactive window
• Visual Studio code
  • Alt+Enter - send selection to REPL/Interactive window

• You can reference dll files, other script and source files
• Use it to explore code quickly without a project
• Use open instead of using to reference a namespace

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 

#r "APathToA.dll"
#load "APathToAnotherScript.fsx"
#load "APathToASourceFile.hs"

open System

let x = 10
let time = DateTime.Now

• Execute in two ways:
  • Alt+Enter in IDE
  • fsi --exec file.fsx

Same as for C# but with some minor changes

• Source code are kept in .fs files
• The project file is a .fsproj instead of .csproj
• File ordering matter, files must be in dependency order in the project file
• F# projects can reference C# dlls
• C# projects can reference F# dlls
• You can mix F# and C# in one solution

Everything in F# is an expression

1: 

let x = if true then 100

• Doesn't compile since if is an expression, not a statement like in C#.
• Return values are used instead of mutation

• (in the sample above the else clause has an implicit unit return value)

When assigning a variable a value, you bind that variable to the value. The value can be a function or an actual value

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 

// bind the value 5 to the variable x
let x = 5

// bind the function x + y to add
let add = fun x y -> x + y

// false, here it is a pattern match and not bind
x = x + 1

• Built in types (those that are used in the workshop)

1: 
2: 
3: 
4: 
5: 

let x = 1                   // int
let y = 1.                  // the . indicates that this is a float
let z = true                // bool
let w = "tomas"             // string
let v = System.DateTime.Now // DateTime

• Type aliases

1: 
2: 

type MyString = string
type MyInt = int

• Record types

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

type Author = {Name: string; Age: int}
let tomas = {Name = "tomas"; Age = 35}
let tomas2 = 
    {
        Name = "tomas"
        Age = 35
    }
tomas = tomas2 // true, because of structural comparison
               // and = is equal and not assignment
// Create new record based on old one
let tomasInOneYear = {tomas with Age = tomas.Age + 1}
tomas = tomasInOneYear // false

• Tuples

1: 
2: 

let x = ("tomas", 35)
let (name, age) = x

• Discriminated union

1: 
2: 
3: 
4: 
5: 

type Shape = 
    | Rectangle of int * int
    | Circle of Radius:int

let shapes = [ Rectangle(1,69); Circle(69) ]

• Function types (finally some functions)

1: 
2: 

// myFun : x:int -> y:int -> int (this is the type of the function)
let myFun x y = x + y

• Measure types

1: 
2: 
3: 

type [<Measure>] Km
type [<Measure>] Hour
let x = 10.<Km>/1.<Hour> // x: float<Km/Hour>

Now when you've seen some code it is time for some gotchas:

• Order matters
• Structure matters (F# uses signficant space)
• F# types use structural equality by default
• F# types are immutable by default
• F# types are not nullable by default
• F# has good type inference (but sometimes you need to help the compiler)

1: 
2: 
3: 
4: 

//         in type1   in type2    return type
//            |          |           |
//            V          V           V
let myFun (x:string) (y:string) : string = x + y

• Learn how to create types
• Learn how to use the FSI to experiment
• Try to play around with the code while going through the exercises

• Clone the github repo: https://github.com/mastoj/FSharpIntro
• Open branch module1
• Open the solution file in the src folder
• Open script.fsx
• Create the following types:

• Type alias named CustomerId of type int
• Measure type called Point
• Points type of type float<Point>
• Type alias CustomerName of type string
• Record type GoldData that has a property PromotedDate of type DateTime

• Discriminated union type FrequentFlyerStatus with two cases
  • Regular with no field
  • Gold with one field of type GoldData
• Record type Customer that has the following properties
  • Id of type CustomerId
  • Name of type CustomerName
  • Points of type Points
  • FrequentFlyerStatus of type FrequentFlyerStatus

• Measure type called Km
• Distance type of type float<Km>
• Type alias named DestinationName of type string
• Type alias named DestinationId of type int
• Record type Destination that has the following properties
  • Id of type DestinationId
  • Name of type DestinationName

• Measure type called SEK
• Price type of type float<SEK>
• Type alias named DestinationName of type string
• Type alias named DestinationId of type int
• Discriminated union type TicketClass with three cases
  • Economy with no field
  • Business with no field
  • FirstClass with no field

• Record type Ticket that has the following properties
  • CustomerId of type CustomerId
  • Price of type Price
  • TicketClass of type TicketClass
  • From of type Destination
  • To of type Destination

Functions in F# are curried, that is, they only have 1 argument!

1: 
2: 

let add x y = x + y
let add x = fun y -> x + y

When you apply a function partially you get a new function back

1: 
2: 
3: 

let add x y = x + y
let add5 y = add 5 y
let add5 = add 5        // fun y -> 5 + y

You can both use functions as argument or return values of functions

• Returning a function

1: 
2: 

let add x y = x + y
let add5 = add 5

• Function as argument

1: 
2: 
3: 
4: 

let add x y = x + y
let add5 = add 5
let addWith adder x = adder x
addWith add5 5                  // 10

Functional operators are common in F#, and they are not as complicated as they seem. Two of the most common ones are the pipeline operator and function composition. You can easily define your own as well.

• |> pipeline operator

1: 
2: 
3: 

(|>)    // ('a -> ('a -> 'b) -> 'b)

let (|>>>) = fun x f -> f x

• >> function composition

1: 
2: 
3: 

(>>)     // (('a -> 'b) -> ('b -> 'c) -> 'a -> 'c)

let (>>>>) = fun f1 f2 a = f2 (f1 a)

Built in type to use instead of null --> force explicit handling of missing values and a semantic meaning. It is implemented as a generic discriminated union.

1: 
2: 
3: 

type Option<'T> = 
    | None
    | Some of 'T

Can be used with any F# types:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 

// Pattern match on tuple
let myTuple = "tomas"*35
let (name, age) = myTuple

// Pattern match on discriminated union
let maybeAdd x maybeY = 
    match maybeY with
    | None -> x
    | Some y -> x + y

let isSome s = 
    match s with
    | None -> false
    | Some _ -> true // _ don't care match

• Lists
  • immutable native F# lists

1: 
2: 

let intList = [1;2;3]
let intList = [1..3]

• Arrays
  • mutable arrays, more memory efficient

1: 
2: 

let intList = [|1;2;3|]
let intList = [|1..3|]

• Sequences (IEnumerable)
  • lazy
  • can be infinite

1: 
2: 

let intSeq1 = seq { yield 1; yield 2}
let intSeq2 = seq { yield! intSeq1; yield 3; yield 4}

Of course you can pattern match on lists as well.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

let rec sumAll xs = 
    match xs with
    | [] -> 0                       // base case
    | [x::xs'] -> x + sumAll xs'    // recursive case

// With tail recursion to avoid stack overflow
let sumAll2 xs = 
    let rec inner xs acc = 
        match xs with
        | [] -> acc
        | [x::xs'] -> inner xs' (acc + x)
    inner xs 0

You can also attach functions to types

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 

type Person =
    {
        Name: string
        Age: int
    }
    with 
        static member create name age = {Name = name; Age = age}
        member this.isAdult() = this.Age > 18

let tomas = {Name = "tomas"; Age = 35}
tomas.isAdult() // true

• Apply some structure to the project
• Basic functionality

• If you finished module1 you can continue with the code
• If you did not finish module1, checkout module2
• Copy all the types from Script.fsx to Types.fsx

• Open the test project
• Comment out the first test in the CustomerTests module inside TypesTest.fs
• Implement a static create function on the Customer type
• Comment out the last two and implement the instance function isGoldMember()

• Comment out the first test in the DestinationTests module inside TypesTest.fs
• Implement a static create function on the Destination type

• Comment out the first test in the TicketTests module inside TypesTest.fs
• Implement a static create function on the Ticket type

Option.map "lifts" a regular function a function that handles option

1: 
2: 
3: 
4: 

let add5 x = 5 + x
let maybeAdd5 = Option.map add5
maybeAdd5 None          // None
maybeAdd5 (Some 10)     // Some 15

Option.bind "lifts" a function that does not take an Option as input but returns it to a function that only deals with Option types

1: 
2: 
3: 
4: 

let safeDiv10 y = if y = 0 then None else Some (10/y)
let optSafeDiv10 = Option.bind safeDiv10
optSafeDiv10 None       // None
optSafeDiv10 (Some 2)   // Some 5

Available functions are in the Option namespace, use Visual Studio to see what is available.

Most of the functions in the List module are also available in the Seq or Array module. Some of the List functions and their LINQ counterpart

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 

let numbers = [ 1 .. 10 ]
let evenNumbers = numbers |> List.filter (fun x -> x % 2 = 0)
let sum = numbers |> List.fold (fun x y -> x + y) 0
let double = numbers |> List.map ((*) 2)
let doubleSum = 
    numbers
    |> List.map ((*) 2)
    |> List.fold (+) 0

Check the List module for more functions.

• Implement the domain logic for our ticketing system

• Comment out one test at a time from the ConversionTests module in FunctionsTests.fs
• Add a F# source file named Functions.fs in the FSharpIntro project below Types.fs (right click Types.fs and choose Add below -> New Item...)
• Add open System and open Types belove the top module definition
• Add a sub module Conversion in the new file

1: 

module Conversion =

• Add the implementation that passes the test to this module, note that the functions need to be indented under this module
• (Hint on next page)

Implementation of the first function:

1: 

let priceToPoints (price: float<SEK>)= price * 1.<Point/SEK>

• Copy the file Lists.fs and add it over Types.fs
• Add a new module in the Functions.fs file named Customer

1: 

module Customer =

• Comment out one test at a time and make it pass
• When implementing calculatePoints you can use the takeXOrAll function in Lists.fs

• Add a new module in the Functions.fs file named `Ticket

1: 

module Ticket = 

• Comment out one test at a time and make it pass

A Map can be thought of as a immutable Dictionary

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 

// Map.ofList
[1,2; 2,1] |> Map.ofList // map [(1, 2); (2, 1)]

// Map.toList
[1,2; 2,1] |> Map.ofList |> Map.toList // [(1, 2); (2, 1)]

// Map.add
[1,2; 2,1] |> Map.ofList |> Map.add 3 4 // map [(1, 2); (2, 1); (3, 4)]

// Map.find
[1,2; 2,1] |> Map.ofList |> Map.find 1 // 2

// Map.tryFind
[1,2; 2,1] |> Map.ofList |> Map.tryFind 1 // Some 2

Use Map.find if you know that the value exists, otherwise use tryFind and deal with the missing key.

• In F# you want to avoid mutability, but some times it makes sense to bypass the default rules
• You can create mutable variables by using the keyword mutable and the <- operator to "re-bind" a variables.
• Try to do it at the edges or keep it local

The syntax is similar to records but you take arguments after the type name.

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 

type Person(name, age) = 
    let isAdult = age > 18
    do printfn "%s is adult: %A" name isAdult
    member this.Name = name // get & private set of Name
    member this.Age = age   // get & private set of age
    member this.IsAdult = isAdult

let tomas = Person("tomas", 35)
let tomas = new Person("tomas", 35)

An interface is a type with just abstract members.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 

type Adder = 
    abstract member Add: int -> int -> int

type AdderImpl() = 
    interface Adder with
        member this.Add x y = x + y

let adder = AdderImpl()
adder.Add 3 4 // ERROR
(adder :> Adder).Add 3 4 // 7 -- (:>) is a type safe cast

It is possible to implement an interface in F# without implementing a class. It is done by a so called Object expression.

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 

type Adder = 
    abstract member Add: int -> int -> int

let adder = 
    { new Adder
        with member this.Add x y = x + y }

adder.Add 3 4 // 7, no need to cast since adder is of type Adder

• Implement in-memory data storage
• Learn more about lists, maps, OO and mutability

• Add the file Data.fs below the Functions.fs file
• Comment out one test a time and make it pass
• Key functions you might want to use
  • List.mapi
  • List.collect
  • Map.ofList
• There are hints to get you started on the next two slides

Some helper values:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

let private destinationList = 
    [ "Barcelona"; "Stockholm"; "Oslo" ] 
    |> List.mapi Destination.create
let private distanceList = 
    [ (0,1,2789.2); (0,2,2141.16); (1,2,530.) ]
    |> List.collect (fun (index1, index2, distance) -> 
        let typedDistance = distance |> createDistance
        [
            (destinationList.[index1], destinationList.[index2]), typedDistance
            (destinationList.[index2], destinationList.[index1]), typedDistance
        ])
    |> Map.ofList

• Comment out the TicketsTests and implement the functions it covers
• (This is probably not the best example of a good unit test)

• Comment out the tests in CustomerTests class one at a time and make it pass
• Note that we are using a class here so we can initialize the tests in the constructor block. That is the code after do.

• Create a new file below Data.fs and name it Services.fs
• Add the class DestinationService to the file

1: 

type DestinationService() = 

• Add the following member functions that just call the functions in the Data module:

1: 
2: 
3: 
4: 

member this.GetDestinations = // add correct function call here
member this.GetDestination destinationId = // , here
member this GetDistance ((destination1, destination2) as key) = // , here
member this.GetPrice ((destination1, destination2) as key, ticketClass) // and here

• Add the class TicketService
• Add the members functions GetTicketsForCustomer and SaveTicket

• Add the class CustomerService
• Add the member functions GetCustomer, GetCustomers, AddCustomer and UpdateCustomer

This time we will test that the code work through the FSI. Open up the file Script1.fsx and paste in the following to get you started:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

#load "Lists.fs"
#load "Types.fs"
#load "Functions.fs"
#load "Data.fs"
#load "Services.fs"

open Services

let customerService = new CustomerService()
customerService.GetCustomers()
customerService.AddCustomer "Tomas"
customerService.GetCustomer 0

Run with Alt+Enter in Visual Studio.

When composing components it is done in mostly two different places:

• Compose types
• Compose functions

Can be used to define external interface from an application

1: 
2: 
3: 
4: 
5: 
6: 
7: 

type App =
    {
        getCustomers: unit -> Customer list
        addCustomer: CustomerName -> Customer option
        reserveTicket: ReserveTicketRequest -> (Customer * Ticket) option
        getTickets: CustomerId -> Ticket list
    }

Sometimes the function you want to expose does not match in type and/or structure with the domain function, or you need to combine multiple functions together.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 

let createTicket request customer = 
    let ticket = Domain.createTicket customer request // Wrapping domain function
    match ticket with
    | None -> None
    | Some ticket -> Some (customer, ticket) // Creating new return value

let reserveTicket ticketRequest : (Customer, Ticket) option =
    getCustomer customerId  // returns Customer option
    Option.bind (createTicket ticketRequest) // Return option
    ...

let app = {
    reserveTicket: reserveTicket
}

• Gluing the pieces together

• Add an Application.fs file below Services.fs
• Create a record type ReserveTicketRequest with the properties
  • CustomerId: CustomerId
  • From: DestinationId
  • To: DestinationId
  • TicketClass: TicketClass
• Create another record type App with the properties
  • getCustomers: unit -> Customer list
  • addCustomer: CustomerName -> Customer option
  • reserveTicket: ReserveTicketRequest -> (Customer * Ticket) option
  • getTickets: CustomerId -> Ticket list

• Add a createApp function in the bottom of the file (and keep it there always)
• createApp should have three arguments
  • customerService: CustomerService
  • ticketService: TicketService
  • destinationService: TestinationService

• createApp should return a App

1: 
2: 
3: 
4: 
5: 
6: 
7: 

{
    getCustomers = customerService.GetCustomers
    addCustomer = customerService.AddCustomer
    reserveTicket = 
        (reserveTicket customerService ticketService destinationService)
    getTickets = ticketService.GetTicketsForCustomer
}

• Implement a dummy function for reserveTicket
• Try out the createApp with the script file

• Add the reserveTicket function above createApp

1: 
2: 
3: 
4: 

let reserveTicket 
    (customerService: CustomerService) 
    (ticketService: TicketService) 
    (destinationService: DestinationService) reserveTicketRequest = 

• Implement the following functions in the body of reserveTicket, some functions might shadow functions in Functions.fs:

1: 
2: 
3: 
4: 
5: 
6: 
7: 

let tryUpgradeTicketForCustomer (customer, ticket) 
    : (Customer * Ticket) option =

let createTicket 
    reserveTicketRequest
    ((customer: Customer), fromDestination, toDestination) 
    : (Customer * Ticket) option = 

• Use Option.bind and do the following:

  1. get customer
  2. get from destination
  3. get to destination
  4. create ticket
  5. try upgrade ticket for customer
  6. save ticket
  7. update customer
  8. save customer
• Hint on next slide to get you started

• This is mainly boiler plate code so replace Program.fs with the one here.
• This is the first function with recursion, the rec keyword is used
• Try to understand the code (reading code is important)
• Start the application and play around with it