F# Functional Programming

Functional Programming History

• 1950s - Lisp by John McCarthy (MIT)
• 1960s - APL by Kenneth E. Iverson (Harvard)
• 1970s - ML by Robin Milner (University of Edinburgh)
• 1986 - Erlang
• 1990 - Haskell
• 1996 - OCaml
• 2004 - Scala
• 2005 - F# by Don Syme
• 2007 - Clojure
• 2012 - Elm
• 2014 - Swift

F# History

• 2005 - first stable release (F# 1.0)
• Don Syme - language designer
• Open Source since 2010
• Cross-platform
• fsharp.org - F# official page

My Motivation

• Broaden horizons
• Productivity
• Safety
• Reliability
• Robustness
• Joy
• Peace

Alan Perlis: a language that doesn't affect the way you think about programming, is not worth knowing.

Type inference

A mechanism used by compiler to deduce what types are used in expressions in a program.

Type inference

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

let num = 7
let str = "F# rocks!"
let pi = 3.14

let circleArea r = 3.14 * r ** 2.
circleArea 1.

3.14

Type inference - explicit annotations

1: 
2: 
3: 
4: 

open System
let getTomorrow (today: DateTime) =
    today.AddDays(1.)
let tomorrow = getTomorrow DateTime.UtcNow

24.09.2016 16:41:57

Immutability

• no side-effects
• no mutation of a state
• no modifications of other parts of a program

Immutability

1: 
2: 
3: 

let x = 7
// x = x + 1 // WRONG!!
let y = x + 1 // GOOD

8

Currying

... means transforming a function with many arguments,

into a series of functions,

each with only one argument.

All functions in F# are auto-curried by compiler.

Currying

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

let add x y = x + y

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

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

Partial Application

... means passing to function less arguments

than it originally accepts.

As a result function returns another function,

which accepts remaining parameters.

Partial Application

1: 
2: 
3: 
4: 
5: 

let addNumbers x y = x + y

let increment = addNumbers 1

increment 3

4

Higher Order Functions

Functions which:

accept another function as an input,

or return function as an output.

Higher Order Functions

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

let calculate f x y =
    f x y

calculate (+) 3 4

calculate (*) 3 4

7

12

Pattern Matching

Pattern Matching I

1: 
2: 
3: 

let u, _, w = (1, 3, 5)
u
w

1

5

Pattern Matching II

1: 
2: 
3: 
4: 

let a::b::rest = [1..10] 
a
b
rest

1

2

[3; 4; 5; 6; 7; 8; 9; 10]

Pattern Matching III

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

let aList = []
let msg =
    match aList with
    | [] -> "empty" 
    | [x] -> sprintf "one item: %A" x 
    | [x; y] -> sprintf "two items: %A and %A" x y 
    | _ -> "many items"

"empty"

Structure Equality I

1: 

let eq1 = 4 = 3

false

Structure Equality II

1: 
2: 
3: 

let field1 = ("a", 3)
let field2 = ("a", 5 - 2)
let eq2 = field1 = field2

true

Structure Equality III

1: 
2: 
3: 
4: 

type Person = { Name: string; Age: int }
let m1 = { Name = "Mike"; Age = 22 }
let m2 = { Name = "Mike"; Age = 22 }
let eq3 = m1 = m2

true

Option Type

It is a union of two cases:

• Data is present
• Data is missing

Option Type

1: 
2: 
3: 

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

Option Type

1: 
2: 
3: 
4: 
5: 

let m = Some 5
let result = 
    match m with 
    | Some i -> Some (i * 2)
    | None -> None

Some 10

F# Vital Statistics - Most Loved

F# Vital Statistics - Top Paying Tech US

F# Vital Statistics - Top Paying Tech Worldwide

Summary - F#

• multi-paradigm (FP, OO)
• flexible
• powerful
• functional-first

Summary - F# code

• concise
• clean
• robust
• safe
• expressive
• reusable
• maintainable

F# Developer

Demo