feat(Seq.traverse/sequence*)!: Yield arrays

Author: bartelink

src/FsToolkit.ErrorHandling/Seq.fs

@@ -10,41 +10,44 @@ module FsToolkit.ErrorHandling.Seq
 /// <param name="state">The initial state</param>
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
-/// <returns>A result with the ok elements in a sequence or the first error occurring in the sequence</returns>
+/// <returns>A result with the ok elements in an array or the first error occurring in the sequence</returns>
 let inline traverseResultM'
-    state
+    (state: Result<'okOutput seq, 'error>)
     ([<InlineIfLambda>] f: 'okInput -> Result<'okOutput, 'error>)
     (xs: 'okInput seq)
-    =
+    : Result<'okOutput[], 'error> =
+    if isNull xs then
+        nullArg (nameof xs)
+
     match state with
-    | Error _ -> state
-    | Ok oks ->
+    | Error e -> Error e
+    | Ok initialSuccesses ->
+
         use enumerator = xs.GetEnumerator()
 
-        let rec loop oks =
-            if enumerator.MoveNext() then
-                match f enumerator.Current with
-                | Ok ok ->
-                    loop (
-                        seq {
-                            yield ok
-                            yield! oks
-                        }
-                    )
-                | Error e -> Error e
-            else
-                Ok(Seq.rev oks)
+        let acc = ResizeArray(initialSuccesses)
+        let mutable err = Unchecked.defaultof<'error>
+        let mutable ok = true
+        use e = xs.GetEnumerator()
+
+        while ok
+              && e.MoveNext() do
+            match f e.Current with
+            | Ok r -> acc.Add r
+            | Error e ->
+                ok <- false
+                err <- e
 
-        loop oks
+        if ok then Ok(acc.ToArray()) else Error err
 
 /// <summary>
 /// Applies a function to each element of a sequence and returns a single result
 /// </summary>
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
-/// <returns>A result with the ok elements in a sequence or the first error occurring in the sequence</returns>
-/// <remarks>This function is equivalent to <see cref="traverseResultM'"/> but applying and initial state of 'Seq.empty'</remarks>
-let traverseResultM f xs = traverseResultM' (Ok Seq.empty) f xs
+/// <returns>A result with the ok elements in an array, or the first error occurring in the sequence</returns>
+/// <remarks>This function is equivalent to <see cref="traverseResultM'"/> but applying an initial state of 'Array.empty'</remarks>
+let traverseResultM f xs = traverseResultM' (Ok Array.empty) f xs
 
 /// <summary>
 /// Converts a sequence of results into a single result
@@ -60,39 +63,49 @@ let sequenceResultM xs = traverseResultM id xs
 /// <param name="state">The initial state</param>
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
-/// <returns>A result with the ok elements in a sequence or a sequence of all errors occuring in the original sequence</returns>
-let inline traverseResultA' state ([<InlineIfLambda>] f: 'okInput -> Result<'okOutput, 'error>) xs =
-    let folder state x =
-        match state, f x with
-        | Error errors, Error e ->
-            seq {
-                e
-                yield! Seq.rev errors
-            }
-            |> Seq.rev
-            |> Error
-        | Ok oks, Ok ok ->
-            seq {
-                ok
-                yield! Seq.rev oks
-            }
-            |> Seq.rev
-            |> Ok
-        | Ok _, Error e ->
-            Seq.singleton e
-            |> Error
-        | Error _, Ok _ -> state
+/// <returns>If no Errors encountered, a result with an array of the ok elements from the 'state' followed by those gathered from the sequence, or an array of all errors from the 'state' and/or those in the sequence</returns>
+let inline traverseResultA'
+    (state: Result<'okOutput seq, 'error seq>)
+    ([<InlineIfLambda>] f: 'okInput -> Result<'okOutput, 'error>)
+    xs
+    =
 
-    Seq.fold folder state xs
+    if isNull xs then
+        nullArg (nameof xs)
+
+    match state with
+    | Error failuresToDate ->
+        let errs = ResizeArray(failuresToDate)
+
+        for x in xs do
+            match f x with
+            | Ok _ -> () // as the initial state was failure, oks are irrelevant
+            | Error e -> errs.Add e
+
+        Error(errs.ToArray())
+    | Ok initialSuccesses ->
+
+        let oks = ResizeArray(initialSuccesses)
+        let errs = ResizeArray()
+
+        for x in xs do
+            match f x with
+            | Error e -> errs.Add e
+            | Ok r when errs.Count = 0 -> oks.Add r
+            | Ok _ -> () // no point saving results we won't use given the end result will be Error
+
+        match errs.ToArray() with
+        | [||] -> Ok(oks.ToArray())
+        | errs -> Error errs
 
 /// <summary>
 /// Applies a function to each element of a sequence and returns a single result
 /// </summary>
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>A result with the ok elements in a sequence or a sequence of all errors occuring in the original sequence</returns>
-/// <remarks>This function is equivalent to <see cref="traverseResultA'"/> but applying and initial state of 'Seq.empty'</remarks>
-let traverseResultA f xs = traverseResultA' (Ok Seq.empty) f xs
+/// <remarks>This function is equivalent to <see cref="traverseResultA'"/> but applying an initial state of Array.empty'</remarks>
+let traverseResultA f xs = traverseResultA' (Ok Array.empty) f xs
 
 /// <summary>
 /// Converts a sequence of results into a single result
@@ -146,7 +159,7 @@ let inline traverseAsyncResultM'
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>An async result with the ok elements in a sequence or the first error occurring in the sequence</returns>
-/// <remarks>This function is equivalent to <see cref="traverseAsyncResultM'"/> but applying and initial state of 'Seq.empty'</remarks>
+/// <remarks>This function is equivalent to <see cref="traverseAsyncResultM'"/> but applying an initial state of 'Seq.empty'</remarks>
 let traverseAsyncResultM f xs =
     traverseAsyncResultM' (async { return Ok Seq.empty }) f xs
 
@@ -205,7 +218,7 @@ let inline traverseAsyncResultA'
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>An async result with the ok elements in a sequence or a sequence of all errors occuring in the original sequence</returns>
-/// <remarks>This function is equivalent to <see cref="traverseAsyncResultA'"/> but applying and initial state of 'Seq.empty'</remarks>
+/// <remarks>This function is equivalent to <see cref="traverseAsyncResultA'"/> but applying an initial state of 'Seq.empty'</remarks>
 let traverseAsyncResultA f xs =
     traverseAsyncResultA' (async { return Ok Seq.empty }) f xs
 
@@ -256,7 +269,7 @@ let inline traverseOptionM'
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>An option containing Some sequence of elements or None if any of the function applications return None</returns>
-/// <remarks>This function is equivalent to <see cref="traverseOptionM'"/> but applying and initial state of 'Seq.empty'</remarks>
+/// <remarks>This function is equivalent to <see cref="traverseOptionM'"/> but applying an initial state of 'Seq.empty'</remarks>
 let traverseOptionM f xs = traverseOptionM' (Some Seq.empty) f xs
 
 /// <summary>
@@ -311,7 +324,7 @@ let inline traverseAsyncOptionM'
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>An async option containing Some sequence of elements or None if any of the function applications return None</returns>
-/// <remarks>This function is equivalent to <see cref="traverseAsyncOptionM'"/> but applying and initial state of 'Async { return Some Seq.empty }'</remarks>
+/// <remarks>This function is equivalent to <see cref="traverseAsyncOptionM'"/> but applying an initial state of 'Async { return Some Seq.empty }'</remarks>
 let traverseAsyncOptionM f xs =
     traverseAsyncOptionM' (async { return Some Seq.empty }) f xs
 
@@ -364,7 +377,7 @@ let inline traverseVOptionM'
 /// <param name="f">The function to apply to each element</param>
 /// <param name="xs">The input sequence</param>
 /// <returns>A voption containing Some sequence of elements or None if any of the function applications return None</returns>
-/// <remarks>This function is equivalent to <see cref="traverseVOptionM'"/> but applying and initial state of 'ValueSome Seq.empty'</remarks>
+/// <remarks>This function is equivalent to <see cref="traverseVOptionM'"/> but applying an initial state of 'ValueSome Seq.empty'</remarks>
 let traverseVOptionM f xs =
     traverseVOptionM' (ValueSome Seq.empty) f xs