let add1 x = x + 1

// statement
int result;
if(retryCount > 5)
{
    result = -1;
}

//expression
int result = retryCount > 5 ? -1 : 0;

// statement
var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbers = new List<int>();
foreach (var number in numbers)
{    
    if (number % 2 == 0)
    {
        evenNumbers.Add(number);
    }
}

// expression
var evenNumbers = numbers.Select(number => number % 2 == 0);

let number = 5
let surname = "Kowalski"

let add x y = x + y
let sum = add

let add x y = x + y

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

let add x y = (+) x y

let three = ((add 1) 2)
let three' = (((+) 1) 2)

let add x y = (+) x y

let add10 = (+) 10

let getOblgation connectionString obligationId = ...

let getObligationIoC = getOblgation @"Server=.;Database=db;Trusted_Connection=True;"

let (|>) x f = f x

[1..4]
|> List.filter (fun i -> i > 2)
|> List.sum

let Log level message = sprintf "[%s] - %s" level message
"some warning" |> Log "Warn"

let (>>) f g x = g (f x)

let add x y = x + y
let mul x y = x * y

let add5AndMultiplyBy3 = add 5 >> mul 3

let nothing = ()

let doNothing () = ()

let collection = [| 1; 2; 3; 4; 5 |]

let collection2 = [| 1 .. 5 |]

let collection3 = [| for i in 1 .. 10 -> i * i  |]

let third = collection.[2]

let subCollection = collection.[2..]

let collection = [ 1; 2; 3; 4; 5 ]

let collection2 = [ 1 .. 5 ]

let collection3 = [ for i in 1 .. 10 -> i * i  ]

let third = collection.[2]

let subCollection = collection.[2..]

let collection4 = collection @ collection2

let collection5 = 125 :: collection

let sequence = seq { 1 .. 5 }

let sequence2 = seq { for i in 1 .. 10 -> i * i  }

[1 .. 20 .. 1000]
|> List.map (fun i -> i * 2)        // select
|> List.filter (fun i -> i > 20)    // where
|> List.rev                         // reverse

type ClientId = System.Guid
type DocumentNumber = int
type DocumentData = string
type DocumentTuple = DocumentNumber * DocumentData

type QueryFunction = ClientId -> DocumentTuple list

let printDocuments (query:QueryFunction) (clientId:ClientId) = 
    clientId |> query |> List.iter (fun doc -> printf "%A" doc)

let intANDstring = (1, "str")

let t2 = (true, "data")
let t3 = (1, "data", false)

let n1 = fst t2
let n2 = snd t2
let (b, str) = t2

type DocumentRecord = 
    { Number: DocumentNumber 
      Data: DocumentData 
      IsSigned: bool }

let document = { Number = 1; Data = "data"; IsSigned = false }

let signDocument doc = { doc with IsSigned = true }

let { Data = d; IsSigned = b } = signDocument document

type intORstring = | Int of int | String of string

type Shape =
| Circle of Radius : float
| Triangle of Base : float * Height : float
| Rectangle of Length : float * Height : float

type DocumentRecord' = { Number: DocumentNumber; Data: DocumentData; } 

type DocumentUnion = 
| Unsigned of DocumentRecord'
| Signed of DocumentRecord'

let signDocument (document: DocumentUnion) =
    match document with
    | Signed _ -> document
    | Unsigned doc -> Signed doc

type SignedDocument = SignedDocument of DocumentRecord'

type UnsignedDocument = UnsignedDocument of DocumentRecord'

let signDocument2 (UnsignedDocument record) = SignedDocument record

let printValue optionalInt = 
    match optionalInt with 
    | Some i -> sprintf "Have value %s!" i
    | None -> sprintf "No value"

let posNeg number =
    match number with
    | n when n > 0 -> "positive"
    | n when n < 0 -> "negative"
    | _ -> "zero"

let describe list =
    match list with
    | [] -> "empty"
    | [a] -> sprintf "only %A" a
    | [a; _] -> sprintf "two elements beginning with %A" a
    | _ -> "lots of elements"

let rec sum list =
    match list with
    | head :: tail -> head + sum tail
    | [] -> 0

type Person = { First:string; Last:string }

let matchJohn person = 
    match person with 
    | {First="john"}  -> sprintf "Matched John" 
    | _  -> sprintf "Not John" 

type Customer(firstName, lastName) = 

    // default constructor
    new () =
        Customer("john", "doe")

    member this.FirstName = firstName
    member this.LastName = lastName

    member this.GetFullName() = 
        sprintf "%s %s" this.FirstName this.LastName

let customer = new Customer("John", "Doe")
let fullName = customer.GetFullName()

type CustomerMutable(firstName, lastName) =

    let mutable _firstName = firstName
    let mutable _lastName = lastBame

    member this.FirstName 
        with get() = _firstName
        with set(value) = _firstName <- value

    member this.LastName
        with get() = _lastName
        and set(value) = _lastName <- value

type ICalculator =
    abstract member Add: int -> int -> int
    abstract member Substract: int -> int -> int

    // immutable property
    abstract member Pi : float 

    // read write property
    abstract member CurrentValue : int with get,set

type Calculator() = 
    
    let mutable _currentValue = 0

    interface ICalculator with
        member this.Add x y = x + y
        member this.Substract x y = x - y
        
        member this.Pi = 3.14

        member this.CurrentValue
            with get() = _currentValue
            and set(value) = _currentValue <- value

let calc = new Calculator()
let result = calc.Add 1 2

let calc = 
    { new ICalculator with 
      member this.Add x y = x + y
      member this.Substract x y = x + y
      member this.Pi = 3.14
      member this.CurrentValue with get() = 0 and set(value) = () }

[<Measure>]
type degC

[<Measure>]
type degF

let convertCtoF (temp: float<degC>) = 
    9.0<degF> / 5.0<degC> * temp + 32.0<degF>

let convertFtoC (temp: float<degF>) = 
    5.0<degC> / 9.0<degF> * (temp - 32.0<degF>)

let (|Even|Odd|) n =
    if n % 2 = 0 then Even
    else Odd
    
let testNum n =
    match n with
    | Even -> printfn "%i is even" n
    | Odd -> printfn "%i is odd" n

open System.Text.RegularExpressions

let (|RegexContains|_|) pattern input = 
    let matches = Regex.Matches(input, pattern)
    if matches.Count > 0 
    then Some [ for m in matches -> m.Value ]
    else None

let testString = function
    | RegexContains "http://\S+" urls -> printfn "Urls: %A" urls
    | RegexContains "[^@]@[^.]+\.\W+" emails -> printfn "Emails: %A" emails
    | RegexContains "\d+" numbers -> printfn "Numbers: %A" numbers
    | _ -> printfn "Didn't find anything."

open FSharp.Data

[<Literal>]
let sample = @"{
    ""title"" : ""Management 4.2"",
    ""author"" : {
        ""firstName"" : ""Jurgen"",
        ""lastName"" : ""Appelo""
    },
    ""ISBN"" : ""978-0321123479""
}"

type BookTypes = JsonProvider<sample, RootName="book">

let author = BookTypes.Author("Philip K.", "Dick")
let book = BookTypes.Book("Ubik", author, "isbn")

type OptionBuilder() =
    member x.Bind(v,f) = Option.bind f v
    member x.Return v = Some v
    member x.ReturnFrom o = o
    member x.Zero () = None
let opt = OptionBuilder()

let someValue =
    opt {
        let x = 12
        let! y = Some 11
        return x + y
    }

let noneValue =
    opt {
        let x = 12
        let! y = None
        return x + y
    }