Introduction to Functional Programming in F# – Part 7

let calculate i =
    if i % 3 = 0 && i % 5 = 0 then "FizzBuzz"
    elif i % 3 = 0 then "Fizz"
    elif i % 5 = 0 then "Buzz"
    else i |> string

[1..15] |> List.map calculate

let calculate i =
    match (i % 3, i % 5) with
    | (0, 0) -> "FizzBuzz"
    | (0, _) -> "Fizz"
    | (_, 0) -> "Buzz"
    | _ -> i |> string

let calculate i =
    match (i % 3 = 0, i % 5 = 0) with
    | (true, true) -> "FizzBuzz"
    | (true, _) -> "Fizz"
    | (_, true) -> "Buzz"
    | _ -> i |> string

let calculate i =
    match i with
    | IsDivisibleBy 3 & IsDivisibleBy 5 -> "FizzBuzz"
    | IsDivisibleBy 3 -> "Fizz"
    | IsDivisibleBy 5 -> "Buzz"
    | _ -> i |> string

let (|IsDivisibleBy|_|) divisor n  = // int -> int -> 
unit option
    if n % divisor = 0 then Some () else None

let calculate i =
    match i with
    | IsDivisibleBy 3 & IsDivisibleBy 5 & IsDivisibleBy 7 -> 
"FizzBuzzBazz"
    | IsDivisibleBy 3 & IsDivisibleBy 5 -> "FizzBuzz"
    | IsDivisibleBy 3 & IsDivisibleBy 7 -> "FizzBazz"
    | IsDivisibleBy 5 & IsDivisibleBy 7 -> "BuzzBazz"
    | IsDivisibleBy 3 -> "Fizz"
    | IsDivisibleBy 5 -> "Buzz"
    | IsDivisibleBy 7 -> "Bazz"
    | _ -> i |> string

let calculate mapping n =
    let isDivisibleBy (divisor, result) = if n % divisor = 0 
then result else ""
    let handleEmpty input = if input = "" then n |> 
string else input
    mapping
    |> List.map isDivisibleBy
    |> List.fold (+) "" 
    |> handleEmpty

[1..15] |> List.map (fun n -> ([(3, "Fizz"); (5, "Buzz")], n) 
||> calculate)
[1..15] |> List.map (fun n -> ([(3, "Fizz"); (5, "Buzz"); 
(7, "Bazz")], n) ||> calculate)

let isLeapYear year =
    year % 400 = 0 || (year % 4 = 0 && year % 100 <> 0)

let (|IsDivisibleBy|_|) divisor n  =
    if n % divisor = 0 then Some () else None

let (|NotDivisibleBy|_|) divisor n  =
    if n % divisor <> 0 then Some () else None

let isLeapYear year =
    match year with
    | IsDivisibleBy 400 -> true
    | IsDivisibleBy 4 & NotDivisibleBy 100 -> true
    | _ -> false

let isDivisibleBy divisor year =
    year % divisor = 0

let notDivisibleBy divisor year =
    not (year |> isDivisibleBy divisor)

let isLeapYear year =
    year |> isDivisibleBy 400 || (year |> isDivisibleBy 4 && 
year |> notDivisibleBy 100)

open System

let (|IsValidDate|_|) input = // string -> DateTime option
    let (success, value) = DateTime.TryParse(input)
    if success then Some value else None

let parse input =
    match input with
    | IsValidDate d -> printfn "%A" d
    | _ -> printfn "%s is not a valid date" input

let isDate = parse "2019-12-20" // 2019-12-20 00:00:00
let isNotDate = parse "Hello" // Hello is not a valid date

(0, 0) (0, 0) = 400 // 300 + 100 + 0 * 15 + 0 * 20
(3, 2) (3, 2) = 485 // 300 + 100 = 3 * 15 * 2 * 20
(5, 1) (4, 3) = 180 // 100 + 4 * 15 + 1 * 20
(2, 1) (0, 7) = 20 // 0 * 15 + 1 * 20
(2, 2) (3, 3) = 170 //100 + 2 * 15 + 2 * 20

type Score = int * int

let (|CorrectScore|_|) (expected:Score, actual:Score) =
    if expected = actual then Some () else None

let (|Draw|HomeWin|AwayWin|) (score:Score) =
    match score with
    | (h, a) when h = a -> Draw
    | (h, a) when h > a -> HomeWin
    | _ -> AwayWin

let (|CorrectResult|_|) (expected:Score, actual:Score) =
    match (expected, actual) with
    | (Draw, Draw) -> Some ()
    | (HomeWin, HomeWin) -> Some ()
    | (AwayWin, AwayWin) -> Some ()
    | _ -> None

let (|CorrectResult|_|) (expected:Score, actual:Score) =
    match (expected, actual) with
    | ((h, a), (h', a')) when h = a && h' = a' -> Some ()
    | ((h, a), (h', a')) when h > a && h' > a' -> Some ()
    | ((h, a), (h', a')) when h < a && h' < a' -> Some ()
    | _ -> None

let goalsScore (expected:Score) (actual:Score) =
    let (h, a) = expected
    let (h', a') = actual
    let home = [ h; h' ] |> List.min
    let away = [ a; a' ] |> List.min
    (home * 15) + (away * 20)

let calculatePoints (expected:Score) (actual:Score) =
    let pointsForCorrectScore = 
        match (expected, actual) with
        | CorrectScore -> 300
        | _ -> 0
    let pointsForCorrectResult =
        match (expected, actual) with
        | CorrectResult -> 100
        | _ -> 0
    let pointsForGoals = goalsScore expected actual
    pointsForCorrectScore + pointsForCorrectResult + 
pointsForGoals

let assertnoScoreDrawCorrect = calculatePoints (0, 0) 
(0, 0) = 400
let assertHomeWinExactMatch = calculatePoints (3, 2) 
(3, 2) = 485
let assertHomeWin = calculatePoints (5, 1) (4, 3) = 180
let assertIncorrect = calculatePoints (2, 1) (0, 7) = 20
let assertDraw = calculatePoints (2, 2) (3, 3) = 170

let goalsScore (expected:Score) (actual:Score) =
    let home = [ fst expected; fst actual ] |> List.min
    let away = [ snd expected; snd actual ] |> List.min
    (home * 15) + (away * 20)

let resultScore (expected:Score) (actual:Score) =
    match (expected, actual) with
    | CorrectScore -> 400
    | CorrectResult -> 100
    | _ -> 0

let calculatePoints (expected:Score) (actual:Score) =
    let pointsForResult = resultScore expected actual
    let pointsForGoals = goalsScore expected actual
    pointsForResult + pointsForGoals

let calculatePoints (expected:Score) (actual:Score) =
    [ resultScore; goalsScore ]
    |> List.sumBy (fun f -> f expected actual)