Trying to derive an Async<Result<'a, 'e>> from the generic monad CE

[brandedoutcast]

Hey guys,

I'm banging my head with monads & monad transformers. I'm trying to derive a simple asyncResult CE using the generic monad CE. I tried all possible combinations of lift & ReturnT but couldn't get it to compile

I'm trying to write a thin wrapper function around HttpClient named sendAsync I'm aware of the task CE available in FSharp but I would like to use async CE, I could either define a AsyncResultBuilder by hand or use FSToolkit.ErrorHandling library's asyncResult & it'd work but I really want to learn how to do this using FSharpPlus monad CE

I'm stuck with this since 2 days been reading too many things in Haskell & F# but couldn't fix the compiler errors any help is deeply appreciated

The first type is Result<'a, 'e> and the final type is Async<Result<'a, 'e>> so I tried wrapping the first expression in async so it becomes Async<Result<'a, 'e>> assuming it would work but it didn't & also wrapping async just to satisfy types to bind feels wrong & I assumed lift or ResultT.hoist would do it in a generic way & I'm really sold by the point that I don't have to define individual combinations of builders like AsyncResultBuilder with generic monad and monad transformers like ResultT I just can't seem to figure out how though as cracking this will result in being able to create any type of combinational monads without actually defining them by hand

#r "nuget: FSharpPlus, 1.6.1"

open System
open FSharpPlus
open FSharpPlus.Data
open System.Net.Http

type Request<'a> = { Url: string; Data: 'a option }
type Response<'a> = { StatusCode: int; Body: 'a }

let deserializeJson s = Ok s
let serializeToJson s = Ok s

let toStringContent body = new StringContent(body, Text.Encoding.UTF8, "application/json")

let private execAsync (client: HttpClient) reqMsg = async {
  try
    let! res = client.SendAsync(reqMsg) |> Async.AwaitTask
    let! content = res.Content.ReadAsStringAsync() |> Async.AwaitTask

    return monad {
      let! body = if content = "" then Ok None else content |> deserializeJson |> Result.map Some
      return {
        StatusCode = int res.StatusCode
        Body = body
      }
    }
  with ex ->
    return Error ex.Message
}

let sendAsync c { Url = url; Data = data } =
  use reqMsg = new HttpRequestMessage(HttpMethod.Post, url)

  match data with
  | None -> execAsync c reqMsg
  | Some d -> monad {
      let! content = d |> serializeToJson
      reqMsg.Content <- content |> toStringContent
      return! execAsync c reqMsg
    }

let rec sendStrictAsync c req = monad {
  let! res = sendAsync c req

  return!
    match res.StatusCode = 200 with
    | true -> Ok res
    | false -> Error "StatusCode [%d{res.StatusCode}] indicates failure"
}

[brandedoutcast]

@gusty I went through a bunch of SO replies you posted & issues on this repo especially this one #135 but still can't figure out how to accomplish what I want

[gusty]

Type inference gets tricky with monad transformers and generics in F#.
Anyways, your code is missing some transformations, in the right side of the let! = ... there must be a ResultT<Async<Result....

Then in order to get a ResultT from a Result you should use ResultT.hoist.

let sendAsync c ({ Url = url; Data = data } : Request<string>) =
  use reqMsg = new HttpRequestMessage(HttpMethod.Post, url)

  match data with
  | None -> ResultT (execAsync c reqMsg)
  | Some d -> monad {
      let! content = ResultT.hoist (serializeToJson d)
      reqMsg.Content <- content |> toStringContent
      return! ResultT (execAsync c reqMsg)
    }

let rec sendStrictAsync c req = monad {
  let! res = sendAsync c req

  return!
    match res.StatusCode = 200 with
    | true -> ResultT.hoist (Ok res)
    | false -> ResultT.hoist (Error "StatusCode [%d{res.StatusCode}] indicates failure")
}

But note that the above code does not compile without adding the annotation : Request<string> at the beginning, because type inference assumes it generic first, then when resolving SRTPs that generic becomes an obj.
Giving an early hint that is not a generic solves the issue here.

I hope this helps to understand Monad Transformers, but if you want to write code more aligned with stuff like FsToolkit you can create your own 4 liner asyncResult CE easily like this:

#r "nuget: FSharpPlus, 1.6.1"

open System
open FSharpPlus
open FSharpPlus.Data
open System.Net.Http

[<AutoOpen>]
module CEs =
    type AsyncResultBuilder<'t> () =
        inherit MonadFxBuilder<ResultT<'t>> ()
        member _.Source x = ResultT x
        member _.Run (x: ResultT<'t>) = ResultT.run x

    let asyncResult<'t> = AsyncResultBuilder<'t> ()



type Request<'a> = { Url: string; Data: 'a option }
type Response<'a> = { StatusCode: int; Body: 'a }

let deserializeJson s = Ok s
let serializeToJson s = Ok s

let toStringContent body = new StringContent(body, Text.Encoding.UTF8, "application/json")

let private execAsync (client: HttpClient) reqMsg = async {
  try
    let! res = client.SendAsync(reqMsg) |> Async.AwaitTask
    let! content = res.Content.ReadAsStringAsync() |> Async.AwaitTask

    return monad {
      let! body = if content = "" then Ok None else content |> deserializeJson |> Result.map Some
      return {
        StatusCode = int res.StatusCode
        Body = body
      }
    }
  with ex ->
    return Error ex.Message
}

let sendAsync c ({ Url = url; Data = data }) =
  use reqMsg = new HttpRequestMessage(HttpMethod.Post, url)

  match data with
  | None -> execAsync c reqMsg
  | Some d -> asyncResult {
      let! content = async.Return (serializeToJson d)
      reqMsg.Content <- content |> toStringContent
      return! (execAsync c reqMsg)
    }

let rec sendStrictAsync c req = asyncResult {
  let! res = sendAsync c req

  return!
    match res.StatusCode = 200 with
    | true -> async.Return (Ok res)
    | false -> async.Return (Error "StatusCode [%d{res.StatusCode}] indicates failure")
}

Note that it works pretty much like the ones in FsToolkit, the most important difference is that you have to explicitly convert (for instance here let! content = async.Return (serializeToJson d)) which IMHO is a good thing as it's a good practice in FP which allows you to reason about the code.

[brandedoutcast]

Thanks a lot for the solution & such a cool library

I understand the code but I'm still trying to fully comprehend the concept of composing monads with monad transformers. I wish the docs had more info & I believe the library is designed for users with prior Haskell knowledge so the logical step is to learn concepts from Haskell & apply them to F# & as someone who is starting out with F# I understand that once these abstractions are learnt the documentation becomes less necessary, but any references to Haskell docs would still be greatly beneficial

In the example I skipped it for brevity but the serializeToJson does take a generic type & serialize it to string & the reverse is true for deserializeJson so the type annotation would be Request<'a>

But if there's no way to get it compiled using generics then I'm totally happy with the alternative solution as the CE is concise but I wonder how complex would this get if I were to do it for multiple monad combinations like AsyncResultOption

I tried defining it like this but couldn't really do what I expected it to i.e.

• return Ok None when data option is None
• return Ok Some Response<'a> when data option is Some

type AsyncResultOptionBuilder<'t> () =
  inherit MonadFxBuilder<OptionT<ResultT<'t>>> ()
  member _.Source x = OptionT (ResultT x)
  member _.Run x = ResultT.run (OptionT.run x)

let asyncResultOption<'t> = AsyncResultOptionBuilder<'t> ()

let sendAsync c { Url = url; Data = data } = asyncResultOption {
  use reqMsg = new HttpRequestMessage(HttpMethod.Post, url)

  let! d = // unwrap data option somehow

  let! content = serializeToJson d
  reqMsg.Content <- content |> toStringContent

  // turn this into a valid return type
  return! execAsync c reqMsg
}

[gusty]

I believe the library is designed for users with prior Haskell knowledge so the logical step is to learn concepts from Haskell & apply them to F# & as someone who is starting out with F# I understand that once these abstractions are learnt the documentation becomes less necessary, but any references to Haskell docs would still be greatly beneficial

Not really, composing monads is a common problem in many FP languages, Monad Transformers is just one alternative and it's true the first implementation was in Haskell, but today we find them in other languages. This particular implementation doesn't match exactly the ones in Haskell, mainly due to lack of higher kinds.

FYI: for v2 we're moving Monad Transformers out of the core of this library, it will be a separate dll.

I think is wrong to think this library is designed for users with prior Haskell knowledge, you can have Scala or Purescript knowledge and have a good understanding as well, to me these are intermediate/advanced FP concepts, which already crossed the "Haskell-thing" boundaries.

But if there's no way to get it compiled using generics

Yes, there are ways, but you'll be fighting type inference from time to time.

Regarding your new code sample, I'm a bit unsure what to say as your type signatures don't match. Try always writing some hardcoded values like let! x = async.Return (if true then Ok (Some 1) else Error "") (note the error part in order to help type inference) or Unchecked.defaultof<Async<Result<Option<int>,string>>> and once you have everything compiling try changing them one by one.

Anyways, my advice is try to stay away of more than 2 layered monads, you should strive to reduce complexity, also combining side effects like reqMsg.Content <- content |> toStringContent with pure code is not a good idea, either use side effects or pure code (which force you to layered monads), or if you need both, keep them separated.

[wallymathieu]

Indeed. I’m coming from more of a Java, C# background and then moved into F# as modeling, POC and script language (previously used a mix of Ruby, Python and C#). F#+ has been a lot of help for what I’ve done. The abstractions part has helped my understanding and modeling in as languages even though I’m not using them all of the times.

[brandedoutcast]

I think is wrong to think this library is designed for users with prior Haskell knowledge, you can have Scala or Purescript knowledge and have a good understanding as well, to me these are intermediate/advanced FP concepts, which already crossed the "Haskell-thing" boundaries.

By Haskell I meant users with prior FP knowledge. As a C# developer venturing into the functional paradigm, I understand that F# lacks higher kinded types but offers computation expressions and it's own unique features & I would appreciate FSharpPlus documentation illustrating the idiomatic use of its types, such as ResultT, or directing to resources like the Grokking monads series. Without FSharpPlus, I might have missed out on that incredible series of articles

Anyways, my advice is try to stay away of more than 2 layered monads, you should strive to reduce complexity, also combining side effects like reqMsg.Content <- content |> toStringContent with pure code is not a good idea, either use side effects or pure code (which force you to layered monads), or if you need both, keep them separated.

Functional concepts intrigue me purely out of curiosity, and I've grown to value FSharpPlus for its assistance in my journey. Indeed, I'm starting to recognize the importance of striking a balance between readability and maintainability with the exciting aspects of functional programming

[gusty]

I'm happy to hear that our work helped you in your road to learning FP, and yes, this library has a proven record of helping C# developers who are curious about FP.

Actually there are some links in the docs, like the one you mentioned, please feel free to suggest more links in the docs, specifically where it's needed.