# F#

Aggelos Biboudis

15/1/2015

## Functional Programming

• Application of functions
• Functions are first-class citizens
• Avoid state and mutation
• Call the function twice and get the same answer
• Expressions, not statements

## History

• Alonzo Church - Lambda calculus (1930)
• John McCarthy - Lisp (1958)
• Robin Milner - ML (1970)
• Gérard Huet - Caml (1985)
• Xavier Leroy - OCaml (1996)
• Don Syme - F# (2005)

## F#

• a statically typed programming language
• functional
• object oriented
• imperative
• explorative
• for .NET (anywhere)
• with open source compiler

## Functions

``````> let add (a:int) (b:int) = a + b;;

val add : a:int -> b:int -> int

> let add a b = a + b;;

val add : a:int -> b:int -> int

val it : (int -> int) = <fun:it@35>

> let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2);;

val fib : n:int -> int

> let apply f a b = (f a b);;

val apply : f:('a -> 'b -> 'c) -> a:'a -> b:'b -> 'c

val it : int = 7
``````

## composition and pipelining

``````> let function1 x = x + 1;;

val function1 : x:int -> int

> let function2 x = x * 2;;

val function2 : x:int -> int

> let h = function1 >> function2;;

val h : (int -> int)

> (>>);;

val it : (('a -> 'b) -> ('b -> 'c) -> 'a -> 'c) = <fun:it@10>

> let result = 100 |> function1 |> function2;;

val result : int = 202``````

## lambdas

``````> apply (fun a b -> a + b) 3 4;;

val it : int = 7``````

## Datatypes (tuples, records)

``````> let tuple = (1, "two");; // tuples

val tuple : int * string = (1, "two")

> type record = { Id : int; Name : string };; //records

type record =
{Id: int;
Name: string;}

> let customer = { Id = 3 ; Name = "Aggelos"};;

val customer : record = {Id = 3;
Name = "Aggelos";}

``````

## Datatypes (discriminated unions)

``````> type switchstate =
| On
| Off;;

type switchstate =
| On
| Off

> let x = On;;

val x : switchstate = On

> type switchstate =
| On
| Off

type switchstate =
| On
| Off

val z : switchstate = Adjustable 0.25``````

## Datatypes (Lists)

``````> let numbers = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10];;
val numbers : int list

> numbers;;
val it : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

> 1 :: 2 :: 3 :: [];;
val it : int list = [1; 2; 3]

> [1 .. 10];;
val it : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

> List.rev [1 .. 5];;
val it : int list = [5; 4; 3; 2; 1]

> [1 .. 10] |> List.filter (fun x -> x % 2 = 0);;
val it : int list = [2; 4; 6; 8; 10]

> [1 .. 10] |> List.map (fun x -> (x * x).ToString());;
val it : string list
= ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]
``````

## pattern matching

``````> let greeting name =
match name with
| "Aggelos" | "George" -> "Hello!"
| "Maria" -> "Hola!"
| _ -> "DOES NOT COMPUTE!";;

val greeting : name:string -> string

> let rec printList list =
match list with
| x :: xs -> printf "%d " x; printList xs
| [] -> printfn "";;

val printList : xs:int list -> unit

> let list1 = [ 1; 5; 100; 450; 788 ];;

val list1 : int list = [1; 5; 100; 450; 788]

> printList list1;;

1 5 100 450 788

val it : unit = () ``````

## IMPerative programming

``````> let mutable x = 5;;

val mutable x : int

> x;;
val it : int = 5

> x <- 10;;
val it : unit = ()

> x;;
val it : int = 10
``````

## object oriented programming

``````> type Account(number : int, holder : string) = class
let mutable amount = 0m

member x.Number = number
member x.Holder = holder
member x.Amount = amount

member x.Deposit(value) = amount <- amount + value
member x.Withdraw(value) = amount <- amount - value
end

type Account =
class
new : number:int * holder:string -> Account
member Deposit : value:decimal -> unit
member Withdraw : value:decimal -> unit
member Amount : decimal
member Holder : string
member Number : int
end

``````

## object oriented programming

``````> let bob = new Account(123456, "Bob’s Savings");;

val bob : Account

> bob.Deposit(100M);;
val it : unit = ()

> bob.Withdraw(29.95M);;
val it : unit = ()``````

• inheritance
• interfaces
• events
• namespaces
• modules

## Thank you

Resources at http://fsharp.org/

Code / Structure inspired by the F# Programming Wikibook and the F# Language Reference.

#### F#

By Aggelos Biboudis

• 2,698