Introduction to Functional Programming in F# – Part 12

dotnet new console -lang F#

namespace ComputationExpression

module OptionDemo =

    let multiply x y = // int -> int -> int
        x * y

    let divide x y = // int -> int -> int option
        if y = 0 then None
        else Some (x / y)

    let calculate x y =
        divide x y
        |> function 
            | Some v -> multiply v x |> Some
            | None -> None
        |> function
            | Some t -> divide t y
            | None -> None

let calculate x y =
        divide x y
        |> Option.map (fun s -> multiply s x)
        |> Option.bind (fun x -> divide x y)

[<AutoOpen>]
module Option =

    type OptionBuilder() =
        // Supports let!
        member __.Bind(x, f) = Option.bind f x
        // Supports return
        member __.Return(x) = Some x
        // Supports return!
        member __.ReturnFrom(x) = x

    // Computation Expression for Option
    let option = OptionBuilder()

let calculate x y =
        option {
            let! first = divide x y
            let second = multiply first x
            let! third = divide second y
            return third
        }

let calculate x y =
        option {
            let! first = divide x y
            let second = multiply first x
            return! divide second y
        }

open ComputationExpression.OptionDemo

[<EntryPoint>]
let main argv =
    let result = calculate 8 0
    printfn "calculate 8 0 = %A" result
    printfn "result is None = %b" result.IsNone
    let result = calculate 8 2
    printfn "calculate 8 2 = %A" result
    0

dotnet add package FsToolkit.ErrorHandling

namespace ComputationExpression

module ResultDemo =

    open FsToolkit.ErrorHandling

    type Customer = {
        Id : int
        IsVip : bool
        Credit : decimal
    }

    let getPurchases customer = // Customer -> Result<(Customer * decimal),exn>
        try
            // Imagine this function is fetching data from a Database
            let purchases = if customer.Id % 2 = 0 then (customer, 120M) else (customer, 80M)
            Ok purchases
        with
        | ex -> Error ex

    let tryPromoteToVip purchases = // Customer * decimal -> Customer
        let customer, amount = purchases
        if amount > 100M then { customer with IsVip = true }
        else customer

    let increaseCreditIfVip customer = // Customer -> Result<Customer,exn>
        try
            // Imagine this function could cause an exception
            let result = 
                if customer.IsVip then { customer with Credit = customer.Credit + 100M }
                else { customer with Credit = customer.Credit + 50M }
            Ok result
        with
        | ex -> Error ex

    let upgradeCustomer customer =
        customer 
        |> getPurchases 
        |> Result.map tryPromoteToVip
        |> Result.bind increaseCreditIfVip

let upgradeCustomer customer =
    result {
        let! purchases = getPurchases customer
        let promoted = tryPromoteToVip purchases
        return! increaseCreditIfVip promoted
    }

namespace ComputationExpression

module AsyncDemo =

    open System.IO

    type FileResult = {
        Name: string
        Length: int
    }

    let getFileInformation path =
        async {
            let! bytes = File.ReadAllBytesAsync(path) |> Async.AwaitTask
            let fileName = Path.GetFileName(path)
            return { Name = fileName; Length = bytes.Length }
        }

open ComputationExpression.AsyncDemo

"""D:\temp\export.csv""" // Replace with a file on your system
    |> getFileInformation
    |> Async.RunSynchronously
    |> printfn "%A"

namespace ComputationExpression

module AsyncResultDemo =

    open System
    open FsToolkit.ErrorHandling

    type AuthError =
        | UserBannedOrSuspended

    type TokenError =
        | BadThingHappened of string

    type LoginError = 
        | InvalidUser
        | InvalidPwd
        | Unauthorized of AuthError
        | TokenErr of TokenError

    type AuthToken = AuthToken of Guid

    type UserStatus =
        | Active
        | Suspended
        | Banned

    type User = {
        Name : string
        Password : string
        Status : UserStatus
    }

[<Literal>]
    let ValidPassword = "password"
    [<Literal>]
    let ValidUser = "isvalid"
    [<Literal>]
    let SuspendedUser = "issuspended"
    [<Literal>]
    let BannedUser = "isbanned"
    [<Literal>]
    let BadLuckUser = "hasbadluck"
    [<Literal>]
    let AuthErrorMessage = "Earth's core stopped spinning"

let tryGetUser (username:string) : Async<User option> =
        async {
            let user = { Name = username; Password = ValidPassword; Status = Active }
            return
                match username with
                | ValidUser -> Some user
                | SuspendedUser -> Some { user with Status = Suspended }
                | BannedUser -> Some { user with Status = Banned }
                | BadLuckUser -> Some user
                | _ -> None
        }

    let isPwdValid (password:string) (user:User) : bool =
        password = user.Password

    let authorize (user:User) : Async<Result<unit, AuthError>> =
        async {
            return 
                match user.Status with
                | Active -> Ok ()
                | _ -> UserBannedOrSuspended |> Error 
        }

    let createAuthToken (user:User) : Result<AuthToken, TokenError> =
        try
            if user.Name = BadLuckUser then failwith AuthErrorMessage
            else Guid.NewGuid() |> AuthToken |> Ok
        with
        | ex -> ex.Message |> BadThingHappened |> Error

let login (username: string) (password: string) : Async<Result<AuthToken, LoginError>> =
        asyncResult {
            let! user = username |> tryGetUser |> AsyncResult.requireSome InvalidUser
            do! user |> isPwdValid password |> Result.requireTrue InvalidPwd
            do! user |> authorize |> AsyncResult.mapError Unauthorized
            return! user |> createAuthToken |> Result.mapError TokenErr
        }

module AsyncResultDemoTests =

    open AsyncResultDemo

    [<Literal>]
    let BadPassword = "notpassword"
    [<Literal>]
    let NotValidUser = "notvalid"

    let isOk (input:Result<_,_>) : bool =
        match input with
        | Ok _ -> true
        | _ -> false

    let matchError (error:LoginError) (input:Result<_,LoginError>) =
        match input with
        | Error ex -> ex = error
        | _ -> false  

    let runWithValidPassword (username:string) = 
        login username ValidPassword |> Async.RunSynchronously

    let success =
        let result = runWithValidPassword ValidUser
        result |> isOk 

    let badPassword =
        let result = login ValidUser BadPassword |> Async.RunSynchronously
        result |> matchError InvalidPwd

    let invalidUser =
        let result = runWithValidPassword NotValidUser
        result |> matchError InvalidUser

    let isSuspended =
        let result = runWithValidPassword SuspendedUser
        result |> matchError (UserBannedOrSuspended |> Unauthorized)

    let isBanned =
        let result = runWithValidPassword BannedUser
        result |> matchError (UserBannedOrSuspended |> Unauthorized)

    let hasBadLuck =
        let result = runWithValidPassword BadLuckUser
        result |> matchError (AuthErrorMessage |> BadThingHappened |> TokenErr)

printfn "Success: %b" success
printfn "BadPassword: %b" badPassword
printfn "InvalidUser: %b" invalidUser
printfn "IsSuspended: %b" isSuspended
printfn "IsBanned: %b" isBanned
printfn "HasBadLuck: %b" hasBadLuck