Impl traverseTaskResultM' traverseTaskResultM

Author: bartelink

src/FsToolkit.ErrorHandling/Seq.fs

@@ -167,6 +167,51 @@ let traverseAsyncResultM f xs =
 /// <remarks>This function is equivalent to <see cref="traverseAsyncResultM"/> but auto-applying the 'id' function</remarks>
 let sequenceAsyncResultM xs = traverseAsyncResultM id xs
 
+/// <summary>
+/// Applies a function to each element of a sequence and returns a single Task result
+/// </summary>
+/// <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 task result with the ok elements in an array or the first error encountered in the state or the sequence</returns>
+let inline traverseTaskResultM'
+    (state: TaskResult<'okOutput seq, 'error>)
+    ([<InlineIfLambda>] f: 'okInput -> TaskResult<'okOutput, 'error>)
+    (xs: 'okInput seq)
+    : TaskResult<'okOutput[], 'error> =
+    if isNull xs then
+        nullArg (nameof xs)
+
+    task {
+        match! state with
+        | Error e -> return Error e
+        | Ok initialSuccesses ->
+            let oks = ResizeArray(initialSuccesses)
+            let mutable ok = true
+            let mutable err = Unchecked.defaultof<'error>
+            use e = xs.GetEnumerator()
+
+            while ok
+                  && e.MoveNext() do
+                match! f e.Current with
+                | Ok r -> oks.Add r
+                | Error e ->
+                    ok <- false
+                    err <- e
+
+            return if ok then Ok(oks.ToArray()) else Error err
+    }
+
+/// <summary>
+/// Applies a function to each element of a sequence and returns a single Task result
+/// </summary>
+/// <param name="f">The function to apply to each element</param>
+/// <param name="xs">The input sequence</param>
+/// <returns>A task 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="traverseTaskResultM'"/> but applying an initial state of 'Seq.empty'</remarks>
+let traverseTaskResultM f xs =
+    traverseTaskResultM' (TaskResult.ok Seq.empty) f xs
+
 /// <summary>
 /// Applies a function to each element of a sequence and returns a single async result
 /// </summary>

tests/FsToolkit.ErrorHandling.Tests/Seq.fs

@@ -470,7 +470,6 @@ let traverseAsyncResultATests =
         }
     ]
 
-
 let sequenceAsyncResultMTests =
     let userIds =
         seq {
@@ -512,6 +511,50 @@ let sequenceAsyncResultMTests =
         }
     ]
 
+let traverseTaskResultATests =
+    let userIds =
+        seq {
+            userId1
+            userId2
+            userId3
+            userId4
+        }
+        |> Seq.map UserId
+
+    testList "Seq.traverseTaskResultA Tests" [
+        testCaseAsync "traverseTaskResultA with a sequence of valid data"
+        <| async {
+            let expected =
+                userIds
+                |> Seq.map (fun (UserId user) -> (newPostId, user))
+                |> Seq.toList
+
+            let! actual = Seq.traverseTaskResultA (notifyNewPostSuccess (PostId newPostId)) userIds
+
+            let actual =
+                Expect.wantOk actual "Expected result to be Ok"
+                |> Seq.toList
+
+            Expect.equal actual expected "Should have a sequence of valid data"
+        }
+
+        testCaseAsync "traverseResultA with few invalid data"
+        <| async {
+            let expected = [
+                sprintf "error: %s" (userId1.ToString())
+                sprintf "error: %s" (userId3.ToString())
+            ]
+
+            let! actual = Seq.traverseTaskResultA (notifyFailure (PostId newPostId)) userIds
+
+            let actual =
+                Expect.wantError actual "Expected result to be Error"
+                |> Seq.toList
+
+            Expect.equal actual expected "Should have a sequence of errors"
+        }
+    ]
+
 let sequenceAsyncOptionMTests =
 
     let userIds =
@@ -723,6 +766,7 @@ let allTests =
         traverseAsyncResultMTests
         traverseAsyncOptionMTests
         traverseAsyncResultATests
+        traverseTaskResultATests
         sequenceAsyncResultMTests
         sequenceAsyncOptionMTests
         sequenceAsyncResultATests