Is there an async validate lib for F#? - f#

Question

I'm using asyncResult a lot in my code but it'll exit at the first error:
asyncResult {
let! a = allGood()
let! b = thisReturnsError()
let! c = neverExecuted()
}
but sometimes I want to execute ALL functions and sum up the errors:
validation {
let! a = doSomething()
and! b = doSomethingElse()
and! c = andAnotherThing()
}
and then I either get an Ok, or a Error with a list of errors.
This is great, but I would like to be able to do both!
asyncValidation {
let! a = doSomethingAsync()
and! b = doSomethingElseAsync()
and! c = andAnotherThingAsync()
}
Is there a lib doing this?

Answer 1

With F#+ you can combine applicatives by using Compose:
#r #"nuget: FSharpPlus"
open FSharpPlus
open FSharpPlus.Data
// Generic applicative CE. At the moment not included in the library.
type ApplicativeBuilder<'a>() =
inherit MonadFxStrictBuilder<'a>()
member inline _.BindReturn(x, f) = map f x
let applicative<'t> = ApplicativeBuilder<'t> ()
let allGoodAsync () : Async<Validation<string, int>> = async { printfn "first success"; return Success 1 }
let thisResturnsErrorAsync () : Async<Validation<string, int>> = async { return Failure "thisReturnsError" }
let neverExecutedAsync () : Async<Validation<string, int>> = async { printfn "actually executed"; return Success 3 }
let x: Async<Validation<string, _>> =
applicative {
let! (a: int) = allGoodAsync () |> Compose
and! (b: int) = thisResturnsErrorAsync () |> Compose
and! (c: int) = neverExecutedAsync () |> Compose
return a + b + c
}
|> Compose.run
let y = Async.RunSynchronously x
results in
>
first success
actually executed
val y: Validation<string,int> = Failure "thisReturnsError"
UPDATE
Revisiting this answer, this could be further simplified as follow:
type ApplicativeBuilder2<'a>() =
inherit Builder<'a>()
member inline _.BindReturn(x, f) = map f x
member inline _.Source x = Compose x
member inline _.Run x = Compose.run x
let applicative2<'t> = ApplicativeBuilder2<'t> ()
So you don't need to mess with Compose :
let x: Async<Validation<string, _>> =
applicative2 {
let! (a: int) = allGoodAsync ()
and! (b: int) = thisResturnsErrorAsync ()
and! (c: int) = neverExecutedAsync ()
return a + b + c
}
and since the F# type inference bug mentioned in the comments still wasn't fixed I can say now that both applicative and applicative2 will be definitely included in next version of F#+.

Answer 2

I just threw this together, but I think it works:
type Validation<'a, 'err> = Result<'a, List<'err>>
type AsyncValidation<'a, 'err> = Async<Validation<'a, 'err>>
module AsyncValidation =
let bind (f : _ -> AsyncValidation<_, _>) (av : AsyncValidation<_, _>) : AsyncValidation<_, _> =
async {
match! av with
| Ok a -> return! (f a)
| Error errs -> return Error errs
}
let ok a : AsyncValidation<_, _> =
async { return Ok a }
let zip (av1 : AsyncValidation<_, _>) (av2 : AsyncValidation<_, _>) : AsyncValidation<_, _> =
async {
let! v1 = av1
let! v2 = av2
match v1, v2 with
| Ok a1, Ok a2 -> return Ok (a1, a2)
| Error errs, Ok _
| Ok _, Error errs -> return Error errs
| Error errs1, Error errs2 -> return Error (errs1 # errs2)
}
type AsyncValidationBuilder() =
member _.Bind(av, f) = AsyncValidation.bind f av
member _.Return(a) = AsyncValidation.ok a
member _.MergeSources(av1, av2) = AsyncValidation.zip av1 av2
let asyncValidation = AsyncValidationBuilder()
Test code:
let doSomethingAsync () = async { return Ok 1 }
let doSomethingElseAsync () = async { return Error ["hello"] }
let andAnotherThingAsync () = async { return Error ["world"] }
let test =
asyncValidation {
let! a = doSomethingAsync ()
and! b = doSomethingElseAsync ()
and! c = andAnotherThingAsync ()
return a + b + c
} |> Async.RunSynchronously
printfn "%A" test // Error ["hello"; "world"]