F# Async let! & return! computation expression

Question

I have started to read stuff about computation expressions and so far as I understand - it has some hidden implementations that are default and custom.

I will provide things that I understand and please correct me.

For example, in this case we define a custom implementation to use let!. So that every expression bound to the let! inside the logger block will be logged to the console.

type LoggingBuilder() =
    let log p = printfn "expression is %A" p

    member this.Bind(x, f) =
        log x
        f x

    member this.Return(x) = x

let logger = new LoggingBuilder()

let loggedWorkflow =
    logger {
        let! x = 42
        let! y = 43
        let! z = x + y
        return z
    }

I cant remember precise but I have read that if we don't provide an implementation to it - it has some default built in. For example some workflow that when it has received None, it will stop the whole workflow and will return just none, if it will return Some - the code will continue -> is this default or not?

Since keywords that are followed by the exclamation mark have some extra functionality behind the scenes, what is it inside the async {} block?

Take this example.

let printerAgent =
    MailboxProcessor.Start
        (fun inbox ->

            // the message processing function
            let rec messageLoop () =
                async {

                    // read a message
                    let! msg = inbox.Receive()

                    // process a message
                    printfn "message is: %s" msg

                    // loop to top
                    return! messageLoop ()
                }

            // start the loop
            messageLoop ())

I presume that the let! msg = inbox.Receive() will stop the workflow if it receives a None. About return! I really have no idea.

Tarmil · Accepted Answer · 2021-10-29 14:00:12Z

1

No, there are no default implementations for computation expression methods. If you want want special behavior for Async<'T option>, you can add an extension method to AsyncBuilder. It looks like you want to short-circuit an Async<unit>, so you would want something like this:

type FSharp.Control.AsyncBuilder with

    member async.Bind(x: Async<'T option>, f: 'T -> Async<unit>) =
        async.Bind(x, function
            | Some x -> f x
            | None -> async.Return())

The computation expression can resolve the overload between several Bind implementations, although you need to be careful: if the types are ambiguous, F# will choose a method implemented on the type itself (in this case, the built-in Bind) over an extension method.

// Here `x` is used as an `int`, so F# knows that it needs to use
// my Bind implementation.
async {
    let! x = myAsyncIntOption
    let y = x + 1
    return ()
}

// Here the type of `x` is unspecified, so F# chooses to use
// the built-in Bind implementation and `x` has type `int option`.
async {
    let! x = myAsyncIntOption
    return ()
}

Now, I've said what can be done, but I wouldn't recommend actually doing this. Instead I would do something more explicit:

let printerAgent =
    MailboxProcessor.Start
        (fun inbox ->

            // the message processing function
            let rec messageLoop () =
                async {

                    // read a message
                    match! inbox.Receive() with
                    | None -> return ()
                    | Some msg ->

                        // process a message
                        printfn "message is: %s" msg

                        // loop to top
                        return! messageLoop ()
                }

            // start the loop
            messageLoop ())

edited Oct 29, 2021 at 14:00

answered Mar 19, 2021 at 9:40

Tarmil

11.4k33 silver badges37 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

kakakakakakakk Over a year ago

you saying that there is no default implementation, then why the let! works inside the async{} ? without specifying any special behavior. Also, i dont get the match! and return!

kakakakakakakk Over a year ago

since it works without any bind implementation, it means that it has a default one.

Brian Berns Over a year ago

let! works inside async{} because there is an explicit implementation of Bind in the AsyncBuilder that ships with F# (link). Without a Bind behind the scenes, there is no default behavior for let!.

Collectives™ on Stack Overflow

F# Async let! & return! computation expression

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related