Missing some functions in OptionAsync

[JosVroegindeweij]

Hello there,

Thanks for making this library, it made me get back into the functional programming world again, but university is so long ago :)

I'm trying to come up with an elegant solution for the following problem:

1. Get data or error from 4 sources (Each has signature EitherAsync<Error, byte[]> GetDataX(Command cmd)).
2. Do something with each individual data that may return errors (Each has signature OptionAsync<Error> ProcessDataX(byte[]))
3. Gather the errors and return them

When errors are encountered in step 1, we should early exit. When errors are encountered in step 2, we should not early exit. In the end, I want to end up with an OptionAsync<Error>, where in the error all errors are accumulated (either a single error if it got returned from GetDataX or a accumulated error if it happened in one or more of ProcessDataX)

I have managed to make the following work (as a simplified example), but I hope this is not the only way

public EitherAsync<Error, Unit> MainFunction(Command cmd) =>
  // Early out is good
  from data1 in GetData1(cmd)
  from data2 in GetData2(cmd)
  from data3 in GetData3(cmd)
  from data4 in GetData4(cmd)
  // No early out anymore
  let process1 = ProcessData1(data1)
  let process2 = ProcessData2(data2)
  let process3 = ProcessData3(data3)
  let process4 = ProcessData4(data4)
  from combined in reduce(
    Seq(process1, process2, process3, process4),
    (errorsSoFar, result) => errorsSoFar.BiBind(
      Left: leftSoFar => result.Match(
        Left: newError => new Error(){ Message: leftSoFar.Message + '\n' + newError.Message },
        Right: _ => leftSoFar
      ),
      Right: _ => result
    )
  )
  select combined;

A few things I dislike about this:

1. I've had to make MainFunction and the ProcessDataX functions return an EitherAsync<Error, Unit> instead of an OptionAsync<Error>. I've tried getting the same results with an OptionAsync<Error> but there is no function OptionAsync<A>.BiBind() in the library and trying to write it myself outside of the library went horribly wrong :)
2. The entire reduce pattern feels clumsy. Surely there is an easier way to combine all the lefts and merge them by some function?

Any help, considerations or pointers would be greatly appreciated!

Edit: I just noticed the title is not very descriptive of the rest of the story I just wrote. The title is about the lack of the BiBind and BiBindAsync methods on OptionAsync.

Also, I just read the proposal for making the OptionAsync and EitherAsync obsolete. How could I use the Aff as proposed there in this use case?

[louthy]

You could try this approach instead: using Lefts which will get all the errors from a collection...

public EitherAsync<Error, Unit> MainFunction(Command cmd) =>
    // Early out is good
    from data1 in GetData1(cmd)
    from data2 in GetData2(cmd)
    from data3 in GetData3(cmd)
    from data4 in GetData4(cmd)
    
    // No early out anymore
    let process1 = ProcessData1(data1)
    let process2 = ProcessData2(data2)
    let process3 = ProcessData3(data3)
    let process4 = ProcessData4(data4)

    // Collect the lefts from the processes.  If there aren't any
    // then return Right, else collect the Errors together and return
    // Left
    from result in Seq(process1, process2, process3, process4)
                       .Lefts()
                       .Map(errors => errors.IsEmpty
                           ? Right<Error, Unit>(unit)
                           : Left<Error, Unit>(Error.Many(errors)))
                       .ToAsync()

    select result;

NOTE: This is using the Error type from language-ext, which allows for the collection of multiple errors.

Really you're trying to do the work of a validation monad rather than an either here. You might want to consider developing a more bespoke monad for your use-case, or use language-ext's Validation monad - it is synchronous though, so you'd need to do your IO work before running the validation process.