let thisIsAnInt = 1
let thisIsAString = "This is a string"
let optionalTypeAnnotation: bool = true

let listOfFloats = [ 1.0; 2.0; 3.0 ]
let arrayOfStrings =
    [| "www.zuehlke.com"
       "www.duckduckgo.com"
       "www.microsoft.com" |]

let add a b =
    a + b

let sign num =
    if num > 0 then "positive"
    elif num < 0 then "negative"
    else "zero"

let rec fib n =
    match n with
    | 1 -> 1
    | 2 -> 1
    | n -> fib(n-1) + fib(n-2)

let printer f = printfn "Number is: %f" f

[0.0..100.0]
|> List.filter (fun i -> i % 2.0 = 0.0)
|> List.map (fun i -> i ** 2.0)
|> List.iter printer
// |> List.iter (fun i -> printer i)

let (|>) value fn =
    fn value

type User =
    { FirstName: string
      LastName: string
      Age: int }

let kai = { FirstName = "Kai"; LastName = "Ito"; Age = 88 }
let cloneOfKai = { FirstName = "Kai"; LastName = "Ito"; Age = 88 }

printfn "%b" (kai = cloneOfKai) // true

let olderKai = { kai with Age = kai.Age + 1 }

printfn "%i" (olderKai.Age) // 89
printfn "%i" (kai.Age) // 88

type Shape =
| Rectangle of width: float * length: float
| Circle of radius: float
| Triangle of float * float * float

let rectangle: Shape = Rectangle (2.0, 5.0)
let circle: Shape = Circle 2.5
let triangle: Shape = Triangle (6.1, 2.0, 3.7)

let whichShape (shape: Shape) =
    match shape with
    | Rectangle (width, length) ->
        printfn "Rectangle with sides %f %f" width length
    | Circle radius ->
        printfn "Circle with radius %f" radius
    | Triangle (side1, side2, side3) ->
        printfn "Triangle with sides %f %f %f" side1 side2 side3

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

let validString: string option = Some "text"
let invalidString: string option = None

let words = [ "hello"; "world"; "from"; "home"; ]
let foundWord = words |> List.tryFind (fun x -> x = "world")
let missingWord = words |> List.tryFind (fun x -> x = "outside")

printfn "The word is: %s" foundWord
// Compile Error: Type mismatch: Expecting "string" but got "string option"

let printString input =
    match input with
    | Some s -> printfn "The word is: %s" s
    | None -> printfn "Didn't find word"

printString foundWord // The word is: world
printString missingWord // Didn't find word

type ContactUser = { Username: string; Email: string option; PhoneNumber: string option }

let createUser username emailAddress phoneNumber =
    // Logic to assign either email address or phone or both
    // Error prone

    { Username = "kaiito"; Email = "kai.ito@zuehlke.com"; PhoneNumber = "123 456 789" }

type ContactInformation =
| Email of string
| PhoneNumber of string
| EmailAndPhone of string * string

type SafeContactUser = { Username: string; Contact: ContactInformation }

let email = Email "kai.ito@zuehlke.com"
let phoneNumber = PhoneNumber "123 456 789"
let emailAndPhone = EmailAndPhone ("kai.ito@zuehlke.com", "123 456 789")

let user1 = { Username = "kaiito1"; Contact = email }
let user2 = { Username = "kaiito2"; Contact = phoneNumber }
let user3 = { Username = "kaiito3"; Contact = emailAndPhone }

let user4 = { Username = "kaiito4"; Contact = null } // Compiler Error
let user5 = { Username = "kaiito5"; Contact = "someString" } // Compiler Error

let parseDateTime (dateTime: string) = DateTime.Parse(dateTime)
let getYear (date: System.DateTime) = date.Year

let date = parseDateTime "26-04-2020 12:00am"
let currentYear: int = getYear date

printfn "The current year is: %i" currentYear
// The current year is: 2020

let composedGetYear: string -> int = parseDateTime >> getYear
let yearFromComposed: int = composedGetYear "26-04-2020 12:00am"

printfn "The current year from composed function is: %i" yearFromComposed
// The current year from composed function is: 2020

let add x y =
    x + y

let add x y =
    x + y

let curriedAdd = add 3
printfn "Result is: %i" (curriedAdd 5)
// Result is: 8

let double = (*) 2

[1..10]
|> List.map double
// [2; 4; 6; 8; 10; 12; 14; 16; 18; 20]

let sum list = List.reduce (+) list
let freeSum = List.reduce (+)

let batchesOf n =
    Seq.mapi (fun i v -> i / n, v) >>
    Seq.groupBy fst >>
    Seq.map snd >>
    Seq.map (Seq.map snd)

[0..10]
|> batchesOf 2 // [[0; 1]; [2; 3]; [4; 5]; [6; 7]; [8; 9]; [10]]

let doubleAndIncrement x = x * 2 + 1
let freeDoubleAndIncrement = (*) 2 >> (+) 1

public string UpdateAndSend(string input)
{
    if (string.IsNullOrWhitespace(input))
        return "empty input"; // Or should we throw an Exception?

    try {
        var updatedUser = UpdateUserInDatabase(input);
        return ConvertToJson(updatedUser);
    }
    catch (DatabaseException e) {
        logger.log(e.Message);
        return "Problem updating user in DB"; // Or should we rethrow?
    }
}

const myPromise =
    (new Promise(() => getDataFromBackend())))
    .then(response => callThirdPartyApi(response.username))
    .then(response => updateHtml(response.data))
    .catch(error => console.log(error));

let result =
    async {
        let! (username: string) = getByIdAsync 1
        let! (replies: string list) = getRepliesByUsernameAsync username

        let count = replies |> List.length

        return (replies, count)
    } |> Async.RunSynchronously