no implicit mutation

recurrence, functions, pattern matchin

functions, record types, union types, function compostion

mutable data

loops, functions, if statements

objects, structs

inheritance, composition, polimorphism

Linq - declarative + functional

Anonymous functions

lambda / delegate 

type inference - var, dynamic

tuple

generics

var current = 0;

foreach(elem in list) {
    current++;
}

List - Count

public void Add(T item) {
            if (_size == _items.Length) EnsureCapacity(_size + 1);
            _items[_size++] = item;
            _version++;
        }

Mutable state

let list = [1..100]

let count list =
    let mutable counter = 0;
    for i in list do
        counter <- counter + 1
    counter
        
count list

let list = [1..10000000]

let rec count list =
    match list with
        | i::tail -> 1 + (count tail)
        | [] -> 0
        
count list       

Recursion!

StackOverflow!

let list = [1..10000000]

let rec count acc list =
    match list with
        | i::tail -> (count (acc + 1) tail)
        | [] -> acc
        
count 0 list     

Tail Recursion

    public class Human
    {
        public int Life { get; set; }

        public Human()
        {
            this.Life = 100;
        }

        public void TakeHit(int val)
        {
            this.Life -= val;
        }
    }

type Human() =
     let mutable _life = 100
     member this.takeHit value = _life <- _life - value
     member this.Life
            with get () = _life

let human = new Human()

type Human(life) =
     let _life = life
     member this.takeHit value = new Human(_life - value)
     member this.Life
            with get () = _life

human.takeHit 10
human.Life

let human = new Human(100)
let newHuman = human.takeHit 10
newHuman.Life

type Item = {
    Id : int
    Name : string
    IsAwesome : bool
    IsActive : bool 
}

let createDefault = {
    Id = 1
    Name = "first"
    IsAwesome = true
    IsActive = true
} 

let first = { createDefault with Name = "first" }
let second = { first with Quantity = 5 }
let third = { second with IsActive = false; IsAwesome = false }

let isAwesomeButNotActive item = 
    match item with
    | { IsActive = false; IsAwesome = true } -> true
    | _ -> false
    
isAwesomeButNotActive { createDefault with IsActive = false }

type Human = {
    Life : int
}

let createNew = {
    Life = 100
}

let takeHit value human = {
    human with Life = human.Life - value
}

let human = createNew
let newHuman = takeHit 10 human

type Human = {
    Life : int
} with member this.takeHit value = {
    this with Life = this.Life - value
}

let createNew = {
    Life = 100
}

let human = createNew
let newHuman = human.takeHit 10

C# - edge cases

public void TakeHit(int val)
{
    if (val < 0) throw new ArgumentOutOfRangeException();

    this.Life -= val;

    if (this.Life < 0) this.Life = 0;
}

F# - edge cases

let takeHit value human = 
    if value < 0 then raise (System.ArgumentException())
    {
        human with Life = if (human.Life - value) < 0 
                          then 0 else human.Life - value
    }

let takeHit value human = 
    if value < 0 then invalidArg "value" "cannot be less than 0"
    ...

let takeHit value human = 
    if value < 0 then invalidArg "value" "cannot be less than 0"
    {
        human with Life = match (human.Life, value) with
                            | (l, v) when l - v < 0 -> 0
                            | (l, v) -> l - v
    }

let takeHit value human = 
    if value < 0 then invalidArg "value" "cannot be less than 0"
    {
        human with Life = match human.Life - value with
                            | difference when difference < 0 -> 0
                            | difference -> difference
    }

public void Attack(Human target)
{
     target.TakeHit(this.Strength); 
}

public void Attack(Human target)
{
     target.TakeHit(this.Strength);
     this.Stamina -= 10;
     if (this.Stamina < 0) this.Stamina = 0;
}

public void Attack(Human target)
{
    if (this.Stamina - 10 < 0) return;

    target.TakeHit(this.Strength);
    this.Stamina -= 10;
    if (this.Stamina < 0) this.Stamina = 0;
}

let attackTarget human target =
    takeHit human.Strength target

let attackTarget human target =
    (
        takeHit human.Strength target, 
        { human with Stamina = human.Stamina - 10 }
    )

let human = createNew
let target = createNew
let (newHuman, newTarget) = attackTarget human target

let difference0 one two = match one - two with
                            | difference when difference < 0 -> 0
                            | difference -> difference 

let attackTarget human target =
    (
        takeHit human.Strength target, 
        { human with Stamina = difference0 human.Stamina 10 }
    )

let private (-@) one two = match one - two with
                            | difference when difference < 0 -> 0
                            | difference -> difference 

let attackTarget human target =
    (
        takeHit human.Strength target, 
        { human with Stamina = human.Stamina -@ 10 }
    )

type ICalc = 
    abstract member Calc: int -> int -> int

let addCalc = 
    { new ICalc with member this.Calc x y = x + y }
        
let calc = addCalc
calc.Calc 1 1

let calc = new Calculator() :> ICalc
calc.Calc 1 1

var fromDB = new ImageRepo(new IMageFromDataBaseProvider());
var fromUrl = new ImageRepo(new IMageFromUrlProvider());
var fromSrv = new ImageRepo(new IMageFromFileProvider());

let imageFrom imageType name =
    imageRepoBuilder imageType name
    
imageFrom URL "test.jpg"
imageFrom DB "test.jpg"
imageFrom SRV "test.jpg"