let fetchAndDownload url =
    // Keyword for starting the async computation expression
    async {
        let client = new System.Net.WebClient()
        // client.AsyncDownloadData returns a value of type Async<byte []>.
        // but by using the let! keyword, bound to "data" is actually the unwrapped inner value of type byte [].
        let! data = client.AsyncDownloadData url
        // This unwrapped value can then conveniently fed into a follow up function.
        let processedData = System.Text.Encoding.ASCII.GetString data
        // The computation expression is finished by returning the result string.
        // This value is again wrapped in the Async wrapper type, resulting in a return value of type Async<string>.
        return processedData
    }

type OptionBuilder() =
    // Return method wraps the final return value in an option
    member this.Return(value : 'T) : 'T Option = 
        printfn $"Return {value}"
        Some value
    // Bind method contains logic for unwrapping the option value and expects an expression that has an option as an return value
    member this.Bind(wrappedValue : 'T option, f : 'T -> 'T option) : 'T option =
        printfn $"Bind {wrappedValue}"
        match wrappedValue with
        | Some unwrappedValue -> 
            f unwrappedValue
        | None -> None
// For easier initialization of the computation expression
let option = OptionBuilder()

type ListBuilder() = 
    /// This will be exposed to the user as `yield`
    member this.Yield(v : 'T) = 
        printfn $"Yield {v}"
        [v]
    /// This will combine the yielded values in the background
    member this.Combine(v1 : 'T list, v2 : 'T list) =
        printfn $"Combine {v1} with {v2}"
        v1 @ v2
    /// This method is needed. It can be used to lazily evaluate the operations in the CE. Instead here, we just directly execute the given function.
    member this.Delay(f : unit -> 'T) = 
        printfn $"Delay"
        let res = f()
        printfn $"Delay result: {res}"
        res
// For easier initialization of the computation expression
let list = ListBuilder()

type ExtendedListBuilder() = 

    /// This will be exposed to the user as `yield`
    member this.Yield(v : 'T) = 
        printfn $"Yield {v}"
        [v]

    /// This will combine the yielded values in the background
    member this.Combine(v1 : 'T list, v2 : 'T list) =
        printfn $"Combine {v1} with {v2}"
        v1 @ v2

    /// This method is needed. It can be used to lazily evaluate the operations in the CE. Instead here, we just directly execute the given function.
    member this.Delay(f : unit -> 'T) = 
        printfn $"Delay"
        let res = f()
        printfn $"Delay result: {res}"
        res

    /// Is called in empty else branches
    member this.Zero() = 
        printfn "Zero"
        []

    /// Allows for using for loops in the computation expression
    member this.For(vs : 'U seq, f : 'U -> 'T list) =
        printfn $"For"
        vs
        |> Seq.collect f
        |> Seq.toList

    /// This will allow for using the yield! method
    member this.YieldFrom(vs : 'T list) =
        printfn $"YieldFrom {vs}"
        vs


// For easier initialization of the computation expression
let extList = ExtendedListBuilder()

extList {
    1
    2
    
    for i in [3;4] do
        i
    
    yield! [5;6]

    if true then 7

}

//Delay
//Yield 1
//Delay
//Yield 2
//Delay
//For
//Yield 3
//Yield 4
//Delay
//YieldFrom [5; 6]
//Delay
//Yield 7
//Delay result: [7]
//Combine [5; 6] with [7]
//Delay result: [5; 6; 7]
//Combine [3; 4] with [5; 6; 7]
//Delay result: [3; 4; 5; ... ]
//Combine [2] with [3; 4; 5; ... ]
//Delay result: [2; 3; 4; ... ]
//Combine [1] with [2; 3; 4; ... ]
//Delay result: [1; 2; 3; ... ]
//val it : int list = [1; 2; 3; 4; 5; 6; 7]

/// Used to specify which mathematical operation should be applied on the float list to reduce it
type MathOperation = 
    | Sum
    | Multiply
    | Custom of (float list -> float)

    /// Apply the given operation on the float list, resulting in a single float
    member this.Apply(vals : float list) =

        match this with
        | Sum -> vals |> List.sum
        | Multiply -> vals |> List.reduce (fun a b -> a * b)
        | Custom operation -> operation vals


type MathBuilder() = 

    // Mutable math operation state, default value is Sum
    let mutable operation = Sum

    /// When the user yields a value of type MathOperation, this will not be added to the list of values but overwrite the state of the operation variable
    member this.Yield(newOperation : MathOperation) =
        operation <- newOperation
        []

    /// User can yield ints
    member this.Yield(v : int) = 
        printfn $"Yield {v}"
        [float v]

    /// User can yield floats
    member this.Yield(v : float) = 
        printfn $"Yield {v}"
        [v]

    /// This will combine the yielded values in the background
    member this.Combine(v1 : float list, v2 : float list) =
        printfn $"Combine {v1} with {v2}"
        v1 @ v2

    /// This method is needed. It can be used to lazily evaluate the operations in the CE. Instead here, we just directly execute the given function.
    member this.Delay(f : unit -> 'T) = 
        printfn $"Delay"
        let res = f()
        printfn $"Delay result: {res}"
        res

    /// Is called in empty else branches
    member this.Zero() = 
        printfn "Zero"
        []

    /// Allows for using for loops in the computation expression
    member this.For(vs : 'U seq, f : 'U -> float list) =
        printfn $"For"
        vs
        |> Seq.collect f
        |> Seq.toList

    /// This will allow for using the yield! method
    member this.YieldFrom(vs : 'T list) =
        printfn $"YieldFrom {vs}"
        vs

    /// This will run the operation on the final float list, returning a single float as output of the compuation expression.
    member this.Run(vs : float list) =
        printfn $"Run {vs}"
        operation.Apply vs

// For easier initialization of the computation expression
let math = MathBuilder()

math {
    1
    2
    3
}

// Results in 6

let factorial x =
    math {
        Multiply
        for i = 1 to x do
            i
    }

factorial 4

//Delay
//Delay
//For
//Yield 1
//Yield 2
//Yield 3
//Yield 4
//Delay result: [1; 2; 3; ... ]
//Combine [] with [1; 2; 3; ... ]
//Delay result: [1; 2; 3; ... ]
//Run [1; 2; 3; ... ]
//val it : float = 24.0

type Cake =

    {
        Size : int
        Filling : string
        PackagedAsPresent: bool
    }

    static member Default = 
        {
            Size = 30
            Filling = "Strawberry"
            PackagedAsPresent = false
        }

type CakeBuilder() =

    member x.Yield (()) = Cake.Default

    member x.Zero () = Cake.Default

    [<CustomOperation("size")>]
    member x.Size (cake : Cake, i: int) =
        {cake with Size = i}
  
    [<CustomOperation("filling")>]
    member x.Filling (cake : Cake, s: string) =
        {cake with Filling = s}

    [<CustomOperation("package")>]
    member x.PackageAsPresent (cake : Cake) =
        {cake with PackagedAsPresent = true}


let cake = CakeBuilder()

cake {
    ()
}

//val it : Cake = { Size = 30
//                  Filling = "Strawberry"
//                  PackagedAsPresent = false }

cake {
    size 1800
    filling "Irish coffee cream"
    package
}

//val it : Cake = { Size = 1800
//                  Filling = "Irish coffee cream"
//                  PackagedAsPresent = true }

For a good example of this kind of computation expression check out [Saturn](https://saturnframework.org/explanations/routing.html)
## Further reading
- [Basic introduction](https://en.wikibooks.org/wiki/F_Sharp_Programming/Computation_Expressions)
- [In depth introduction](https://fsharpforfunandprofit.com/series/computation-expressions/)
- [Official reference](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions)
- [Good video for practical introduction](https://www.youtube.com/watch?v=pC4ZIeOmgB0)