// Imagine a small domain: users have an active subscription, subscriptions have a promo code
type PromoCode = { Code: string; DiscountPct: int }
type Subscription = { Plan: string; PromoCode: PromoCode option }
type User = { Name: string; Subscription: Subscription option }

let findUser (id: int) : User option =
    if id = 1 then Some { Name = "Alice"; Subscription = Some { Plan = "Pro"; PromoCode = Some { Code = "SAVE20"; DiscountPct = 20 } } }
    else None

// --- Before: cascading match expressions ---
// Each optional hop requires its own match arm. Nesting grows with the chain.
let getDiscountNestedMatch (userId: int) : int option =
    match findUser userId with
    | None -> None
    | Some user ->
        match user.Subscription with
        | None -> None
        | Some sub ->
            match sub.PromoCode with
            | None -> None
            | Some promo -> Some promo.DiscountPct

printfn "Nested match: %A" (getDiscountNestedMatch 1)   // Some 20
printfn "Nested match: %A" (getDiscountNestedMatch 99)  // None

// --- Before: Option.bind ---
// Option.bind f opt evaluates to: match opt with None -> None | Some x -> f x
// Piping through Option.bind flattens the nesting, but the lambda noise adds up.
let getDiscountOptionBind (userId: int) : int option =
    findUser userId
    |> Option.bind  (fun user  -> user.Subscription)
    |> Option.bind  (fun sub   -> sub.PromoCode)
    |> Option.map   (fun promo -> promo.DiscountPct)

printfn "Option.bind:  %A" (getDiscountOptionBind 1)   // Some 20
printfn "Option.bind:  %A" (getDiscountOptionBind 99)  // None

// --- With the option computation expression ---
// `let!` unwraps a `Some`, or short-circuits with `None` if the value is absent.
// The happy path reads top-to-bottom with no nesting.
let getDiscountWithCE (userId: int) : int option =
    option {
        let! user  = findUser userId
        let! sub   = user.Subscription
        let! promo = sub.PromoCode
        return promo.DiscountPct
    }

printfn "option CE:    %A" (getDiscountWithCE 1)   // Some 20
printfn "option CE:    %A" (getDiscountWithCE 99)  // None

// A small validation pipeline: parse an order from raw input
type OrderError = InvalidId | NegativeQuantity | UnknownProduct
type Order = { Id: int; ProductId: int; Quantity: int }

let parseId (raw: string) : Result<int, OrderError> =
    match System.Int32.TryParse raw with
    | true, n when n > 0 -> Ok n
    | _ -> Error InvalidId

let validateQuantity (qty: int) : Result<int, OrderError> =
    if qty > 0 then Ok qty else Error NegativeQuantity

let lookupProduct (productId: int) : Result<int, OrderError> =
    if productId = 42 then Ok productId else Error UnknownProduct

// --- Before: cascading match expressions ---
let parseOrderNestedMatch (rawId: string) (qty: int) (productId: int) : Result<Order, OrderError> =
    match parseId rawId with
    | Error e -> Error e
    | Ok id ->
        match validateQuantity qty with
        | Error e -> Error e
        | Ok validQty ->
            match lookupProduct productId with
            | Error e -> Error e
            | Ok pid -> Ok { Id = id; ProductId = pid; Quantity = validQty }

printfn "Nested match: %A" (parseOrderNestedMatch "7" 3 42)   // Ok ...
printfn "Nested match: %A" (parseOrderNestedMatch "7" -1 42)  // Error NegativeQuantity

// --- Before: Result.bind ---
// Flattens the nesting but requires threading intermediate values manually.
let parseOrderResultBind (rawId: string) (qty: int) (productId: int) : Result<Order, OrderError> =
    parseId rawId
    |> Result.bind (fun id ->
        validateQuantity qty
        |> Result.bind (fun validQty ->
            lookupProduct productId
            |> Result.map (fun pid -> { Id = id; ProductId = pid; Quantity = validQty })))

printfn "Result.bind:  %A" (parseOrderResultBind "7" 3 42)   // Ok ...
printfn "Result.bind:  %A" (parseOrderResultBind "abc" 3 42) // Error InvalidId

#r "nuget: FsToolkit.ErrorHandling"

open FsToolkit.ErrorHandling

// --- With the result computation expression (FsToolkit.ErrorHandling) ---
// `let!` unwraps Ok, or short-circuits with the Error value.
// All intermediate values stay in scope — no manual threading.
let parseOrderCE (rawId: string) (qty: int) (productId: int) : Result<Order, OrderError> =
    result {
        let! id       = parseId rawId
        let! validQty = validateQuantity qty
        let! pid      = lookupProduct productId
        return { Id = id; ProductId = pid; Quantity = validQty }
    }

printfn "result CE: %A" (parseOrderCE "7" 3 42)    // Ok { Id = 7; ProductId = 42; Quantity = 3 }
printfn "result CE: %A" (parseOrderCE "abc" 3 42)  // Error InvalidId
printfn "result CE: %A" (parseOrderCE "7" 3 99)    // Error UnknownProduct

// Simulated async data layer
type User    = { Id: int; Name: string }
type Product = { Id: int; Name: string; Price: float }
type Cart    = { UserId: int; ProductIds: int list }

let fetchUser    (id: int)      : Async<User>    = async { return { Id = id; Name = "Alice" } }
let fetchCart    (userId: int)  : Async<Cart>    = async { return { UserId = userId; ProductIds = [1; 2; 3] } }
let fetchProduct (productId: int): Async<Product> = async { return { Id = productId; Name = "Widget"; Price = 9.99 } }

// --- Before: Async.bind ---
// Each hop needs its own Async.bind. Threading `user` and `cart` into
// the final step requires nesting — the same problem as Result.bind.
let getCartTotalBind (userId: int) : Async<float> =
    fetchUser userId
    |> Async.bind (fun user ->
        fetchCart user.Id
        |> Async.bind (fun cart ->
            cart.ProductIds
            |> List.map fetchProduct
            |> Async.Sequential
            |> Async.map (fun products ->
                products |> Array.sumBy (fun p -> p.Price))))

getCartTotalBind 1 |> Async.RunSynchronously |> printfn "Async.bind: %.2f"

// --- With the async computation expression ---
// `let!` suspends until each async completes and binds the result.
// All values stay in scope — no nesting required.
let getCartTotalCE (userId: int) : Async<float> =
    async {
        let! user     = fetchUser userId
        let! cart     = fetchCart user.Id
        let! products = cart.ProductIds |> List.map fetchProduct |> Async.Sequential
        return products |> Array.sumBy (fun p -> p.Price)
    }

getCartTotalCE 1 |> Async.RunSynchronously |> printfn "async CE: %.2f"