refactor(Seq.sequenceResultM)!: Change Ok to Array

Author: bartelink

src/FsToolkit.ErrorHandling/Seq.fs

@@ -1,19 +1,21 @@
-namespace FsToolkit.ErrorHandling
-
 [<RequireQualifiedAccess>]
-module Seq =
+module FsToolkit.ErrorHandling.Seq
+
+let sequenceResultM (xs: seq<Result<'t, 'e>>) : Result<'t[], 'e> =
+    if isNull xs then
+        nullArg (nameof xs)
+
+    let acc = ResizeArray()
+    let mutable err = Unchecked.defaultof<_>
+    let mutable ok = true
+    use e = xs.GetEnumerator()
 
-    let sequenceResultM (xs: seq<Result<'t, 'e>>) : Result<'t seq, 'e> =
-        let rec loop xs ts =
-            match Seq.tryHead xs with
-            | Some x ->
-                x
-                |> Result.bind (fun t -> loop (Seq.tail xs) (t :: ts))
-            | None ->
-                Ok(
-                    List.rev ts
-                    |> List.toSeq
-                )
+    while ok
+          && e.MoveNext() do
+        match e.Current with
+        | Ok r -> acc.Add r
+        | Error e ->
+            ok <- false
+            err <- e
 
-        // Seq.cache prevents double evaluation in Seq.tail
-        loop (Seq.cache xs) []
+    if ok then Ok(acc.ToArray()) else Error err

tests/FsToolkit.ErrorHandling.Tests/Seq.fs

@@ -1,6 +1,5 @@
 module SeqTests
 
-
 #if FABLE_COMPILER_PYTHON
 open Fable.Pyxpecto
 #endif
@@ -12,60 +11,50 @@ open Expecto
 #endif
 open SampleDomain
 open TestData
-open TestHelpers
-open System
 open FsToolkit.ErrorHandling
 
-
 let sequenceResultMTests =
     testList "Seq.sequenceResultM Tests" [
-        testCase "traverseResult with an empty sequence"
+        testCase "sequenceResult with an empty sequence"
         <| fun _ ->
-            let tweets = []
-            let expected = Ok []
+            let tweets = Seq.empty
+            let expected = Ok [||]
 
-            let actual =
-                Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
-                |> Result.map Seq.toList
+            let actual = Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
 
             Expect.equal actual expected "Should have an empty list of valid tweets"
 
-        testCase "traverseResult with a sequence of valid data"
+        testCase "sequenceResult with a sequence of valid data"
         <| fun _ ->
-            let tweets = [
-                "Hi"
-                "Hello"
-                "Hola"
-            ]
+            let tweets =
+                seq {
+                    "Hi"
+                    "Hello"
+                    "Hola"
+                }
 
-            let expected =
-                List.map tweet tweets
-                |> Ok
+            let expected = Ok [| for x in tweets -> tweet x |]
 
-            let actual =
-                Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
-                |> Result.map Seq.toList
+            let actual = Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
 
             Expect.equal actual expected "Should have a list of valid tweets"
 
-        testCase "sequenceResultM with few invalid data"
+        testCase "sequenceResult with few invalid data"
         <| fun _ ->
             let tweets =
-                [
+                seq {
                     ""
                     "Hello"
                     aLongerInvalidTweet
-                ]
-                :> seq<_>
+                }
+
+            let expected = Error emptyTweetErrMsg
 
             let actual = Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
 
-            Expect.equal
-                actual
-                (Error emptyTweetErrMsg)
-                "traverse the sequence and return the first error"
+            Expect.equal actual expected "traverse the sequence and return the first error"
 
-        testCase "sequenceResultM stops after first invalid data"
+        testCase "sequenceResult stops after first invalid data"
         <| fun _ ->
             let mutable counter = 0
 
@@ -81,12 +70,11 @@ let sequenceResultMTests =
                         + 1
                 }
 
+            let expected = Error longerTweetErrMsg
+
             let actual = Seq.sequenceResultM (Seq.map Tweet.TryCreate tweets)
 
-            Expect.equal
-                actual
-                (Error longerTweetErrMsg)
-                "traverse the sequence and return the first error"
+            Expect.equal actual expected "traverse the sequence and return the first error"
 
             Expect.equal counter 0 "evaluation of the sequence stops at the first error"
     ]