asynchronousf#monadsmonad-transformerscomputation-expression

Combine F# async and maybe computation expression


Say i want to return an Option while in an async workflow:

let run = 
    async {
        let! x = doAsyncThing
        let! y = doNextAsyncThing x
        match y with
        | None -> return None
        | Some z -> return Some <| f z
    }

Ideally I would use the maybe computation expression from FSharpx at the same time as async to avoid doing the match. I could make a custom builder, but is there a way to generically combine two computation expressions? It might look something like this:

let run = 
    async {
        let! x = doAsyncThing
        let! y = doNextAsyncThing x
        return! f y
    }

Solution

  • Typically in F# instead of using generic workflows you define the workflow by hand, or use one that is ready available as in your case async and maybe but if you want to use them combined you will need to code a specific workflow combination by hand.

    Alternatively you can use F#+ which is a project that provides generic workflows for monads, in that case it will be automatically derived for you, here's a working example, using your workflow and then using OptionT which is a monad transformer:

    #r "nuget: FSharpPlus, 1.2"
    
    open FSharpPlus
    open FSharpPlus.Data
    
    let doAsyncThing = async {return System.DateTime.Now}
    let doNextAsyncThing (x:System.DateTime) = async {
        let m = x.Millisecond  
        return (if m < 500 then Some m else None)}
    let f x = 2 * x
    
    // then you can use Async<_> (same as your code)
    let run = monad {
        let! x = doAsyncThing
        let! y = doNextAsyncThing x
        match y with
        | None   -> return None
        | Some z -> return Some <| f z}
    
    let res = Async.RunSynchronously run
    
    // or you can use OptionT<Async<_>> (monad transformer)
    
    let run' = monad {
        let! x = lift doAsyncThing
        let! y = OptionT (doNextAsyncThing x)
        return f y}
    
    let res' = run' |> OptionT.run |> Async.RunSynchronously
    

    The first function has to be 'lifted' into the other monad, because it only deals with Async (not with Option), the second function deals with both so it only needs to be 'packed' into our OptionT DU.

    As you can see both workflows are derived automatically, the one you had (the async workflow) and the one you want.

    For more information about this approach read about Monad Transformers.