printfn "Hello, world!"

[<EntryPoint>]
let main args =
    printfn "Hello, %s" args.[0]
    0

let add x y = x + y     // val add : x:int -> y:int -> int
let add' = (+)          // val add' : (int -> int -> int)
let add''(x, y) = x + y // val add'' : x:int * y:int -> int
let add1 = add 1        // val add1 : (int -> int)               

let ``x^2`` =
    fun x -> x ** 2.0                                            

let sqrt = function     // val sqrt : _arg1:float -> float option
| x when
    x < 0.0 ||
    x |> Double.IsNaN ||
    x |> Double.IsInfinity
    -> None
| x -> Some <| Math.Sqrt x

let mult (x : int) (y : int) : int =
    ((x : int) * (y : int) : int)

let mult' (x : int) (y : int) : int =
    (x : int) * (y : int) : int

let add a b = a + b
// val add : a: int -> b : int -> int

let inline add' a b = a + b
// val inline add' :
//   a: ^a -> b: ^b ->  ^c
//     when ( ^a or  ^b) : (static member ( + ) :  ^a *  ^b ->  ^c)

let succ' x = x + LanguagePrimitives.GenericOne
// val succ' : x:int -> int

let inline succ x = x + LanguagePrimitives.GenericOne
// val inline succ :
//   x: ^a ->  ^c
//     when ( ^a or  ^b) : (static member ( + ) :  ^a *  ^b ->  ^c) and
//           ^b : (static member get_One : ->  ^b)

let rec fibonacci = function
| 0 -> 0
| 1 -> 1
| n -> fibonacci(n-1) + fibonacci(n-2)

fibonacci 6             // val it : int = 8

let squared x = x * x
let addTwo x = x + 2

let squareThenAdd = squared >> addTwo   // (f >> g) x ≡ (g ∘ f)(x) ≡ g(f(x))
let addThenSquare = addTwo >> squared

let squareThenAdd' = addTwo << squared  // (f << g) x ≡ (f ∘ g)(x) ≡ f(g(x))
let addThenSquare' = squared << addTwo

squareThenAdd 3     // val it : int = 11
addThenSquare 3     // val it : int = 25
squareThenAdd' 3    // val it : int = 11
addThenSquare' 3    // val it : int = 25

type Foo =
    static member Bar(?c) =
        let c = defaultArg c 1                // val c : int option
        42 * c

let t = (1.0, "Foo")    // val t : float * string
let f = fst t
let s = snd t

let t' = (1.0, "Foo", (2, DateTime.UtcNow))
let (f', s', (i, d)) = t'
let (f'', s'', c') = t'

()                      // val it : unit = ()

let mutable out = 0
let success = Int32.TryParse("3.141", &out)

let success', out' = Int32.TryParse "3.141"

match Int32.TryParse "3.141" with
| true, i -> printfn "%i" i
| _ -> printfn "Failed" 

type Record = { F1 : string; F2 : int }

type Person = {
    FirstName : string
    LastName : string
    DoB : DateTime
    DoD : DateTime option }

let wolfgang = {
    FirstName = "W.A."
    LastName = "Mozart"
    DoB = DateTime(1756, 1, 27)
    DoD = None }

let bizet = {
    FirstName = "Georges"
    LastName = "Bizet"
    DoB = DateTime(1838, 10, 25)
    DoD = None }

var mozart =
    new Person("W.A.", "Mozart", new DateTime(1756, 1, 27))

printfn "%s was born in %i" bizet.FirstName bizet.DoB.Year

let passedAwayWolfgang =
    { wolfgang with DoD = DateTime(1791, 12, 5) |> Some }

type DU =
| Case1
| Case2 of string
| Case3 of int * int
| Case4 of x : float * y : float
| Case5 of inception : DU * DateTime

type SingleCase = SC of string
type SingleGen<'a> = C of 'a

// let invalid (c : Case1) = ()
//                  ^^^^^ the type 'Case1' is not defined

type Opt<'a> =
| Nothing
| Something of 'a
// with
//     ...

let opt = Some 12

if opt |> Option.isNone then
    0
else
    opt |> Option.get

type BinTree<'a> =
| Node of
    left : BinTree<'a> * value : 'a * right : BinTree<'a>
| Leaf of value : 'a
with
    member tree.InOrder = seq {
        match tree with
        | Leaf value -> yield value
        | Node (l, v, r) ->
            yield! l.InOrder
            yield v
            yield! r.InOrder }

let tree =
    Node(Leaf "A", "B", Node(Leaf "C", "D", Leaf "E"))

let flattened = tree.InOrder |> Seq.toList

var tree = new Node(
    new Leaf("A"),
    "B",
    new Node(new Leaf("C"), "D", new Leaf("E")))               

public static IEnumerable<T> InOrder<T>(this BinTree<T> tree)
{
    switch (tree.Tag)
    {
        case BinTree<T>.Tags.Leaf:
            yield return ((BinTree<T>.Leaf)tree).value;
            break;
        case BinTree<T>.Tags.Node:
            var node = (BinTree<T>.Node)tree;
            foreach (var l in node.left.InOrder()) {
                yield return l;
            }
            yield return node.value;
            foreach (var r in node.right.InOrder()) {
                yield return r;
            }
            break;
            // ...

        // ...
        default:
            throw new Exception("Never happens... Right?");
    }
}

tree.IsLeaf, tree.IsNode

let foo = "Foo"
(=)                                                  // val it : bool = true
    { FirstName = "Foo"; LastName = "Bar"; DoB = DateTime(0L); DoD = None }
    { FirstName = foo; LastName = "Bar"; DoB = new DateTime(0L); DoD = None }

Some 12 = Some 12                                    // val it : bool = true
Some(obj()) = Some(obj())                            // val it : bool = false

[<NoEquality; NoComparison>]
type CanNotCompare<'a> = CNC of 'a

// CNC 12 = CNC 33
// ^^^^^^

Some 3 > Some 2       // val it : bool = true
None <= Some 1        // val it : bool = true

let toA = fun () -> "A"
let toB = fun () -> "B"
// Some(toA) <= Some(toB)
//      ^^^

let x = 3 :: [1; 4] @ [1; 5; 9]    // val x : int list = [3;1;4;1;5;9]    
let y = [1 .. 2 .. 5]              // val y : int list = [1;3;5]

let evenSquares =                  // val evenSquares : (int * int) list =
    [for i in 0 .. 5 do            //    [(0, 0), (2, 4), (4, 16)]
        if i % 2 = 0 then
            yield i, i*i]

let evenSquares' = 
  [ -1 .. 5 ]
  |> List.filter (fun i -> i%2 = 0)
  |> List.map (fun i -> i, i * i)

evenSquares = evenSquares'                  // val it : bool = true
obj.ReferenceEquals(1 :: x |> List.tail, x) // val it : bool = true

let notThatMuch = Seq.empty

let range = seq { 1 .. 42 }

let (height, width) = (10, 10)
seq {
    for row in 0 .. width - 1 do
        for col in 0 .. height - 1 ->
            (row, col, row*width + col) }

let fib = Seq.unfold(fun (n1, n2) ->
    Some(n1 + n2, (n2, n1 + n2))) (0I, 1I)
fib |> Seq.item 100

let arr = [| 41; 42 |]

try
    "Something"
with
| :? ArgumentException as ex when ex.Message = "Hi" -> "Hello"
| :? InvalidOperationException -> "Can't do" 
| ex -> sprintf "%s, WTF?" ex.Message

match [1; 2; 3] with
| [] -> "Empty"
| [x] -> "List with only x"
| x :: y :: z :: _ -> "List with at least 3 elements"
| x :: xs -> "List with head x and tail xs"

match Some 2.718 with
| Some e when e > 0.0 -> "Probably e"
| Some 0.0 -> "Zero, for sure"
| Some _ -> "Who cares"
| _ -> "And the rest"

let greet = function
| { FirstName = "W.A."; LastName = ln } ->
    sprintf "My name is W.A., W.A. %s" ln
| { DoD = Some _ } -> "👼"
| { DoB = d } when d > DateTime.UtcNow -> "Marty"
| { FirstName = fn } -> sprintf "Hello, %s" fn

match box 12 with
| :? int -> typeof<int>.Name
| :? double as d -> string d
| _ -> "Rest"

let (|Even|Odd|) x = if x % 2 = 0 then Even else Odd

match 7 with
| Even -> "||"
| Odd  -> "~~"

let (|RGB|) (color : System.Drawing.Color) =
    (color.R, color.G, color.B)

let printRGB = function
    RGB(r, g, b) -> printf "(R:%i, G:%i, B:%i)" r g b

let (|Integer|_|) input =
    match Int32.TryParse input with
    | true, d -> Some d
    | _ -> None

open System.Text.RegularExpressions
let (|Parse|_|) regex input =
    let m = Regex(regex).Match(input)
    if m.Success then
        List.tail [for g in m.Groups -> g.Value] |> Some
    else
        None

match "pwd123" with
| Integer i -> "Key space too small"
| Parse "^(\d{1,2})\.(\d{1,2})\.(\d{1,4})$" [Integer d; Integer m; Integer y] ->
    sprintf "%A... wife or girlfriend?" <| DateTime(y, m, d)
| s -> sprintf "Logging secure password %s" s

Bind : M<'T> * ('T -> M<'U>) -> M<'U>           // let!, do!
Delay : (unit -> M<'T>) -> M<'T>
Return : 'T -> M<'T>                            // return
ReturnFrom : M<'T> -> M<'T>                     // return!
Run : M<'T> -> 'T
Combine : M<'T> * M<'T> -> M<'T>
For : seq<'T> * ('T -> M<'U>) -> M<'U>          // for .. do
TryFinally : M<'T> * (unit -> unit) -> M<'T>    // try .. finally
TryWith : M<'T> * (exn -> M<'T>) -> M<'T>       // try .. with
Using : 'T * ('T -> M<'U>) -> M<'U> when 'U :> IDisposable
While : (unit -> bool) * M<'T> -> M<'T>         // while .. do
Yield : 'T -> M<'T>                             // yield
YieldFrom : M<'T> -> M<'T>                      // yield!
Zero : unit -> M<'T>                            // if .. then .. (no else)

builder.Run(builder.Delay(fun () -> {| cexpr |}))

open System.Threading
let res =
    async {
        let u = Uri("https://caring.dev")
        let ctx = SynchronizationContext.Current
        do! Async.SwitchToThreadPool()
        use client = new System.Net.WebClient()
        let! b = client.AsyncDownloadData u
        let s = System.Text.Encoding.UTF8.GetString b
        do! Async.SwitchToContext ctx
        return s
    }
    |> Async.Catch
    |> Async.RunSynchronously

match res with
| Choice1Of2 r -> printfn "Got %s" r
| Choice2Of2 exn -> printfn "Failed with %s" exn.Message

Meetup:
    topic: "F# intro"
    author: Raphael Schweizer
    contents:
        - Getting started
        - Bindings
        - Functions
        - Datatypes
        - ...
    duration: 2

#I "../../packages/FSharp.Configuration/lib/net45"
#r "FSharp.Configuration.dll"
open FSharp.Configuration

type Config = YamlConfig<"config.yml">

let config = (Config()).Meetup
printfn "The %s meetup takes %ih" config.topic config.duration

<?xml version="1.0" encoding="UTF-8" ?>
<messages xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <message>
        <Available>Foo</Available>
        <Nil xsi:nil="true"/>
        <Missing>Bar</Missing>
        <Missing_Nil>1337</Missing_Nil>
    </message>
    <message>
        <Available>Baz</Available>
        <Nil>3.141</Nil>
    </message>
    <message>
        <Available></Available>
        <Nil>2.718</Nil>
        <Missing_Nil xsi:nil="true"/>
    </message>
</messages>

#I "../../packages/FSharp.Data/lib/net40"
#r "FSharp.Data.dll"
open FSharp.Data

type Message = XmlProvider<"sampleMessages.xml", SampleIsList = true>

let xml = Message.Load("message.xml")

(xml.Available : string option)
let nil : Message.Nil = xml.Nil
(nil.Nil : bool option)
(nil.Value : decimal option)
(xml.Missing : string option)
let missingNil : Message.MissingNil option =
    xml.MissingNil
missingNil |> Option.map(fun mn ->
    (mn.Nil : bool option) |> ignore
    (mn.Value : int option))

var timeout = 12;
Thread.Sleep(timeout);
// Correct? Order of magnitude too long / short?

[<Measure>] type s

[<Measure>]
type ms =
    static member perSecond = 1000.0<ms/s>

let timeout = 12.0<s>
timeout * ms.perSecond  // val it : float<ms> = 12000.0

open Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols

module Symbols =
    let distance = 1.0<m>
    let time = 2.0<s>
    let speed = distance/time
    let acceleration = speed/time
    let mass = 5.0<kg>
    let force : float<N> = mass * speed/time // kg * m / s^2

open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames

module Names =
    let distance = 1.0<metre>
    let time = 2.0<second>
    let speed = distance/time
    let acceleration = speed/time
    let mass = 5.0<kilogram>
    let force : float<newton> = mass * speed/time // kg * m / s^2

type FxRate<[<Measure>] 'u, [<Measure>] 'v> =
    { Rate: float<'u/'v>; Date: DateTime }

[<Measure>] type CHF
[<Measure>] type GBP

let gbp : FxRate<GBP, CHF> list = [
    { Rate = 1.54<GBP/CHF>; Date = DateTime(2015, 11, 27) }
    { Rate = 1.27<GBP/CHF>; Date = DateTime(2016, 7, 8) } ]

let inline op (a : ^T1) (b : ^T2) : ^T3 = a ? b

let inline div a b = a %% b
// val inline div :
//   a: ^a -> b: ^b ->  ^_arg3
//     when ( ^a or  ^b) : (static member ( %% ) :  ^a *  ^b ->  ^_arg3)

let inline (+@) x y = x + x % y
1 +@ 2
3.0 +@ 4.5
// val inline ( +@ ) :
//   x: ^a -> y: ^c ->  ^d
//     when ( ^a or  ^b) : (static member ( + ) :  ^a *  ^b ->  ^d) and
//          ( ^a or  ^c) : (static member ( % ) :  ^a *  ^c ->  ^b)

let inline optionOfNillable n =
    match (^N : (member Nil : bool option) n) with
    | Some true -> None
    | _ -> (^N : (member Value : 'T option) n)

// val inline optionOfNillable :
//   n: ^N -> 'T option
//     when  ^N : (member get_Nil :  ^N -> bool option) and
//           ^N : (member get_Value :  ^N -> 'T)

let nil' =
    xml.Nil |> optionOfNillable
let missingNil' =
    xml.MissingNil |> Option.bind optionOfNillable

open System.Runtime.InteropServices

[<CompiledName("FooC")>]
type ``Foo C#`` =
    static member Bar([<Optional; DefaultParameterValue(null)>] ?c) =
        let c = defaultArg c 1
        42 * c