Question/Feature: partition collections of results into ok cases and error cases.

[bpe-incom]

When dealing with collections of Results it can in some cases be useful partition Ok cases from Error cases. For instance when doing something that can error partially during batch processing or similar I have found myself having to work with a Result<'A, 'B>[] where it would make a lot of sense to return a data structure indicating "Partial Success" and including the Ok cases and Error cases separately.

Therefore, I would find it very useful to have a partition function which also destructures the result types such that I can deal with both ok cases and error cases. I have solved this using this implementation which I thought might be nice to have in this project. The below implementation should of course be extended to other collections as well.

[<RequireQualifiedAccess>]
module Array =
    let partitionResults (input: Result<'a,'b>[]) : 'a[] * 'b[] =                                                                                                                                               
      input |> Array.choose (function Ok v -> Some v | _ -> None),                                                                                                                                            
      input |> Array.choose (function Error e -> Some e | _ -> None) 

Perhaps there is a smarter way of doing this, and if so, I would love to be enlightened.

[bpe-incom]

If you think this could be a nice addition I have a feature branch ready for review

[njlr]

This is almost a built-in?

> [ Ok 1; Error "abc"; Ok 2; Ok 3; Error "def" ] |> List.partition Result.isOk ;;
val it: Result<int,string> list * Result<int,string> list =
  ([Ok 1; Ok 2; Ok 3], [Error "abc"; Error "def"])

Edit: Ah, unless you want to unwrap!

I think an implementation should avoid walking the array / collection twice

[bpe-incom]

What about this implementation then:

let partitionResults (input: Result<'ok, 'error>[]) : 'ok[] * 'error[] =
        let oks, errors =
            Array.foldBack
                (fun x (oks, errors) ->
                    match x with
                    | Ok v -> v :: oks, errors
                    | Error e -> oks, e :: errors)
                input
                ([], [])

        Array.ofList oks, Array.ofList errors

I don't see how we can do it without the Array.ofList which is somewhat annoying, but the Seq implementation can be done in one pass:

let partitionResults (xs: SeqNull<Result<'ok, 'error>>) : 'ok seq * 'error seq =
    if isNull xs then
        nullArg (nameof xs)

    let oks = ResizeArray()
    let errors = ResizeArray()

    for x in xs do
        match x with
        | Ok v -> oks.Add v
        | Error e -> errors.Add e

    oks :> seq<'ok>, errors :> seq<'error>

[njlr]

Your Seq version works for Array too:

module Result =

  let partitionArray (xs : Result<'ok, 'error> array) : 'ok array * 'error array =
    let oks = ResizeArray()
    let errors = ResizeArray()

    for x in xs do
      match x with
      | Ok ok -> oks.Add ok
      | Error error -> errors.Add error

    oks.ToArray(), errors.ToArray()

(BTW, this is not my repo, but I do think this would be useful)

[bartelink]

related: dotnet/fsharp#19335