git clone https://github.com/theimowski/fsharp-workshops-basics.git

cd fsharp-workshops-basics
.\build.cmd KeepRunning

((2+7)/3+(14-3)*4)+3

2 7 + 3 / 14 3 - 4 * + 3 +

// code

let example = "example"

let exercise = "exercise"

let value = 5

let stringValue = "Hi there"
let integerValue = 100

let ``I can have spaces`` = "I really do"

let helloWorld = "Hello World from F# program!"
let replaced = helloWorld.Replace("o", "u")
let substring = replaced.Substring(0, replaced.IndexOf("#") + 1)
let ``example 1.1`` = substring.ToLower()

let initial = 1000.0M
let afterFirstYear = 0
// and so on ...
let ``exercise 1.1`` = 0

let range = [28 .. 38]

let add x y =
    x + y

let addResult = add 5 6

let pipeResult =
    10
    |> add 15
    |> add 6

let lengths = 
    ["F#"; "is"; "the"; "best"]
    |> List.map (fun s -> s.Length)

let isOdd number =
    number % 2 = 1

let ``example 1.2`` = 
    [2 .. 10]
    |> List.filter isOdd
    |> List.map string
    |> String.concat ";"

public static IEnumerable<'T> Where (
    this IEnumberable<'T> sequence, 
    Func<'T, bool> predicate) { ... }

public static bool IsOdd (int number) { return number % 2 == 1; }

numbers.Where (IsOdd)

let filter 
    (predicate : 'a -> bool) 
    (sequence : seq<'a>) = ...

let isOdd number = n % 2 = 1

numbers |> filter isOdd

2 + 4 + 6 + ... + 100

let ``exercise 1.2`` = 0

// no statements - `Console.WriteLine` returns `Unit` ()
let writeLine = System.Console.WriteLine "Hello"

// in let bindings, `=` associates symbol with value
let writeLineIsUnit : bool = 
    // but anywhere else, `=` means equality test
    writeLine = ()

let day =
    if System.DateTime.Now.DayOfWeek = System.DayOfWeek.Thursday then
        "thursday"
    else
        "some other day of week"

let day2 =
    let today = System.DateTime.Now.DayOfWeek 
    if today = System.DayOfWeek.Thursday then
        "thursday"
    else
        "some other day of week"

let workDay =
    let today = System.DateTime.Now.DayOfWeek 
    if today <> System.DayOfWeek.Saturday &&
       today <> System.DayOfWeek.Sunday then
        Some today
    else
        None

let length (value : string) =
    value.Length

let lengthOfWord = length "Hello word"

let parseBool (value : string) =
    let lowercase = value.ToLowerInvariant()
    if lowercase = "true" then
        Some true
    elif lowercase = "false" then
        Some false
    else
        None

let ``example 2.1`` = parseBool "True"

let parseNumber (value: string) : Option<int> =
    None

let ``exercise 2.1`` = parseNumber "42"

let intArray = [|2;4;5|]
let rangeArray = [|10..15|]

let isPalindrome (value : string) =
    let charList = value.ToCharArray()
    let reversed = value.ToCharArray() |> Array.rev
    charList = reversed // this boolean expression returns value

let ``example 2.2`` = isPalindrome "kajak"

let splitBy (separator : char) (str : string) : list<string> =
    []

let ``exercise 2.2`` = 
    "1,3,5,8,10" 
    |> splitBy ',' 

type Size = 
| Small
| Medium
| Large

type Shape =
| Square of edge : float
// `*` in type declarations stands for tuples
| Rectangle of width : float * height : float
| Circle of radius : float

type Result = 
| Success                // no string needed for success state
| ErrorMessage of string // error message needed 

type FruitType =
| Banana
| Apple
| Grapefruit

type Meal = 
| Fruit of FruitType
| Sandwich
| FastFood of string

let ``example 3.1`` = 
    [Sandwich; FastFood "Bar Żuławski"; Fruit Apple]

// `Int` is used here only so that the code compiles. 
// Remove it and instead define proper Discriminated Union cases:
// Operator might be one of the following: Plus, Minus, Multiply or Divide
type Operator = Int

// Same as above:
// Symbol might be either a NumSymbol (with int) or OpSymbol (with Operator)
type Symbol = Int

let formatOptionalValue optionalValue =
    match optionalValue with
    | Some value ->
        "Value: " + value
    | None ->
        "No value at all!"

let formattedValues = 
    [Some "nice string"; None]
    |> List.map formatOptionalValue

let area shape =
    match shape with
    | Square edge -> edge ** 2.0
    | Rectangle (width, height) -> width * height
    | Circle radius -> System.Math.PI * (radius ** 2.0)  

let ``example 3.2`` = area (Circle 10.0)

let apply (operator : Operator) (left : int) (right : int) : int =
    0

// test the function, e.g. `apply Divide 15 4`
let ``exercise 3.2`` = 0

let patternMatchString value =
    match value with
    | "Dog" -> "Animal"
    | "Cat" -> "Animal"
    | x     -> "Something different"

let matchAnimal = patternMatchString "Chair"

let matchFloatingPoint value =
    match value with
    | "1" -> 1.0
    | "2" -> 2.0
    | x   ->
        match x with
        | "1.0" -> 1.0
        | "2.5" -> 2.5
        | y     -> 0.0

let isHealthy meal =
    match meal with
    | Fruit _ -> true
    | Sandwich _ -> false
    | FastFood restaurant ->
        // we can further use matched `restaurant` symbol
        match restaurant with
        | "Green Way" -> true
        | _ -> false

let ``example 3.3`` = 
    FastFood "Bar Żuławski" 
    |> isHealthy

let parseSymbol (token : string) : Option<Symbol> =
    None

let ``exercise 3.3`` = List.map parseSymbol ["+"; "/"; "12"; "uups"] 

let rec sequence (optionals: list<option<'a>>) : option<list<'a>> =
    match optionals with
    | [] -> 
        Some []
    | None :: _ ->
        None
    | Some h :: t ->
        sequence t |> Option.map (fun t -> h :: t)

let parseSymbols (expression: string) : Option<list<Symbol>> =
    None

let ``exercise 3.4`` = "1 2 / +" |> parseSymbols

let rec countdown counter =
    match counter with
    | 0 -> ""
    | x -> x.ToString() + ";" + countdown (counter - 1)

let counting = countdown 10

let rec countdownAcc acc counter =
    match counter with
    | 0 -> acc
    | x -> countdownAcc (acc + ";" + x.ToString()) (counter - 1)
    
let countingAcc = countdownAcc "" 10

let rec factorial x =
    match x with
    | 1 -> 1
    | _ -> (factorial (x-1)) * x

let factorialOf5 = factorial 5

let rec factorialTail acc x =
    match x with 
    | 1 -> acc
    | _ -> factorialTail (x*acc) (x-1)

let factorialOf5Tail = factorialTail 1 5

let rec commaSeparated acc list =
    match list with
    | [] -> acc
    | [single] -> acc + "," + single
    | head :: tail -> commaSeparated (acc + "," + head) tail

let csv = commaSeparated "" ["some";"values";"go";"here"]

let rec formatOptionalInts acc ints =
    match ints with
    | [] -> acc
    | Some 0 :: rest -> formatOptionalInts (acc + " Zero") rest
    | Some x :: rest -> formatOptionalInts (acc + " " + x.ToString()) rest
    | None   :: rest -> formatOptionalInts (acc + " NoValue!") rest

let optionalInts = formatOptionalInts "" [Some 28; Some 0; None]

let rec partitionEvenOdd even odd numbers =
    match numbers with
    | [] ->
        (even, odd)
    | h :: tail when h % 2 = 0 ->
        partitionEvenOdd (h :: even) odd tail
    | h :: tail when h % 2 = 1 ->
        partitionEvenOdd even (h :: odd) tail

let ``example 4.1`` = partitionEvenOdd [] [] [1..10]

let rec compute (stack : list<int>) (symbols : list<Symbol>) : Option<int> =
    None

// test the function, e.g. `compute [] [NumSymbol 4; NumSymbol 2; OpSymbol Multiply]`
let ``exercise 4.1`` : Option<int> = None

let onp (expression : string) : Option<int> = 
    None

let ``exercise 4.2`` = onp "2 7 + 3 / 14 3 - 4 * + 3 +"