F# lazy CE

gistfile1.txt

type NoYieldedValue = NoYieldedValue
type OneYieldedValue<'a> = OneYieldedValue of 'a
type JayzBuilder() =
    // it all starts here ...,
    member _.Zero() = NoYieldedValue

    // we can cause side effects as long as no other value is yielded
    member _.Combine(NoYieldedValue, NoYieldedValue) = NoYieldedValue

    // once a value is yielded, we change the type that flows through the computation
    // to `OneYieldedValue`. Since we have no methods defined on the builder that can
    // operate on `OneYieldedValue`, except of `Delay`, which will end the computation
    // on a call to `Run`.
    member _.Combine(NoYieldedValue, OneYieldedValue b) = b
    member _.Yield(value: 'a) = OneYieldedValue value

    // pass the delayed computation through to the `Run` methods
    member _.Delay(f: unit -> _) = f

    // 1) we support lazy computations that emits nothing (map from `NoYieldedValue` to `unit`)
    member _.Run(f: unit -> NoYieldedValue) = Lazy(())

    // 1) we support lazy computations with one arbitrary yielded value
    member _.Run(f: unit -> OneYieldedValue<'a>) =
        Lazy<'a>(fun () ->
            let (OneYieldedValue value) = f ()
            value
        )

let jayz = JayzBuilder()


// ----------------------------------------


let lazyValue =
    jayz {
        printfn "OHHH (1) Performing heavy computation..."
        printfn "OHHH (2) Performing heavy computation..."
        42
    }

printfn "Before forcing lazyValue... (no heavy computation yet!)"

printfn "Forcing lazyValue: %d" lazyValue.Value




let lazyValue2 =
    lazy
        printfn "OHHH (1) Performing heavy computation..."
        printfn "OHHH (2) Performing heavy computation..."
        42

printfn "Before forcing lazyValue2... (no heavy computation yet!)"

printfn "Forcing lazyValue2: %d" lazyValue2.Value