traverseTaskResultA et al

Author: bartelink

src/FsToolkit.ErrorHandling/Seq.fs

@@ -294,6 +294,73 @@ let traverseAsyncResultA f xs =
 /// <remarks>This function is equivalent to <see cref="traverseAsyncResultA"/> but auto-applying the 'id' function</remarks>
 let sequenceAsyncResultA xs = traverseAsyncResultA id xs
 
+#if !FABLE_COMPILER
+
+/// <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 an array of all errors from the state and the original sequence</returns>
+let inline traverseTaskResultA'
+    (state: TaskResult<'okOutput seq, 'error seq>)
+    ([<InlineIfLambda>] f: 'okInput -> TaskResult<'okOutput, 'error>)
+    (xs: 'okInput seq)
+    : TaskResult<'okOutput[], 'error[]> =
+    if isNull xs then
+        nullArg (nameof xs)
+
+    task {
+        match! state with
+        | Error failuresToDate ->
+            let mutable errs = ArrayCollector()
+            errs.AddMany 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
+
+            return Error(errs.Close())
+        | Ok initialSuccesses ->
+
+            let mutable oks = ArrayCollector()
+            oks.AddMany initialSuccesses
+            let mutable ok = true
+            let mutable errs = ArrayCollector()
+
+            for x in xs do
+                match! f x with
+                | Ok r when ok -> oks.Add r
+                | Ok _ -> () // no point saving results we won't use given the end result will be Error
+                | Error e ->
+                    errs.Add e
+                    ok <- false
+
+            return if ok then Ok(oks.Close()) else Error(errs.Close())
+    }
+
+/// <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 an array of all errors occuring in the sequence</returns>
+/// <remarks>This function is equivalent to <see cref="traverseTaskResultA'"/> but applying an initial state of 'Seq.empty'</remarks>
+let traverseTaskResultA f xs =
+    traverseTaskResultA' (TaskResult.ok Seq.empty) f xs
+
+/// <summary>
+/// Converts a sequence of task results into a single task result
+/// </summary>
+/// <param name="xs">The input sequence</param>
+/// <returns>A task result with all ok elements in an array or an error result with an array of all errors occuring in the sequence</returns>
+/// <remarks>This function is equivalent to <see cref="traverseTaskResultA"/> but auto-applying the 'id' function</remarks>
+let sequenceTaskResultA xs = traverseTaskResultA id xs
+
+#endif
+
 /// <summary>
 /// Applies a function to each element of a sequence and returns a single option
 /// </summary>

tests/FsToolkit.ErrorHandling.Tests/Seq.fs

@@ -452,7 +452,20 @@ let notifyFailure (PostId _) (UserId uId) =
             return Ok()
     }
 
-let traverseAsyncResultATests =
+let traverseTaskResultATests =
+    let notifyNewPostSuccess (PostId post) (UserId user) = TaskResult.ok (post, user)
+
+    let notifyNewPostFailure (PostId _) (UserId uId) = TaskResult.error $"error: %O{uId}"
+
+    let notifyFailure (PostId _) (UserId uId) =
+        if
+            uId = userId1
+            || uId = userId3
+        then
+            TaskResult.error $"error: %O{uId}"
+        else
+            TaskResult.ok ()
+
     let userIds =
         seq {
             userId1
@@ -462,15 +475,17 @@ let traverseAsyncResultATests =
         }
         |> Seq.map UserId
 
-    testList "Seq.traverseAsyncResultA Tests" [
-        testCaseAsync "traverseAsyncResultA with a sequence of valid data"
+    testList "Seq.traverseTaskResultA Tests" [
+        testCaseAsync "traverseTaskResultA with a sequence of valid data"
         <| async {
             let expected =
                 userIds
                 |> Seq.map (fun (UserId user) -> (newPostId, user))
                 |> Seq.toArray
 
-            let! actual = Seq.traverseAsyncResultA (notifyNewPostSuccess (PostId newPostId)) userIds
+            let! actual =
+                Seq.traverseTaskResultA (notifyNewPostSuccess (PostId newPostId)) userIds
+                |> Async.AwaitTask
 
             let actual = Expect.wantOk actual "Expected result to be Ok"
 
@@ -484,7 +499,9 @@ let traverseAsyncResultATests =
                 sprintf "error: %s" (userId3.ToString())
             |]
 
-            let! actual = Seq.traverseAsyncResultA (notifyFailure (PostId newPostId)) userIds
+            let! actual =
+                Seq.traverseTaskResultA (notifyFailure (PostId newPostId)) userIds
+                |> Async.AwaitTask
 
             let actual = Expect.wantError actual "Expected result to be Error"
 
@@ -533,6 +550,46 @@ let sequenceAsyncResultMTests =
 
 #if !FABLE_COMPILER
 
+let traverseAsyncResultATests =
+    let userIds =
+        seq {
+            userId1
+            userId2
+            userId3
+            userId4
+        }
+        |> Seq.map UserId
+
+    testList "Seq.traverseAsyncResultA Tests" [
+        testCaseAsync "traverseAsyncResultA with a sequence of valid data"
+        <| async {
+            let expected =
+                userIds
+                |> Seq.map (fun (UserId user) -> (newPostId, user))
+                |> Seq.toArray
+
+            let! actual = Seq.traverseAsyncResultA (notifyNewPostSuccess (PostId newPostId)) userIds
+
+            let actual = Expect.wantOk actual "Expected result to be Ok"
+
+            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.traverseAsyncResultA (notifyFailure (PostId newPostId)) userIds
+
+            let actual = Expect.wantError actual "Expected result to be Error"
+
+            Expect.equal actual expected "Should have a sequence of errors"
+        }
+    ]
+
 let sequenceTaskResultMTests =
     let notifyNewPostSuccess (PostId post) (UserId user) = TaskResult.ok (post, user)
 
@@ -672,6 +729,58 @@ let sequenceAsyncResultATests =
     ]
 
 #if !FABLE_COMPILER
+let sequenceTaskResultATests =
+    let notifyNewPostSuccess (PostId post) (UserId user) = TaskResult.ok (post, user)
+    let notifyFailure (PostId _) (UserId uId) =
+        if
+            uId = userId1
+            || uId = userId3
+        then
+            TaskResult.error $"error: %O{uId}"
+        else
+            TaskResult.ok ()
+
+    let userIds =
+        seq {
+            userId1
+            userId2
+            userId3
+            userId4
+        }
+        |> Seq.map UserId
+
+    testList "Seq.sequenceTaskResultA Tests" [
+        testCaseAsync "sequenceTaskResultA with a sequence of valid data"
+        <| async {
+            let expected =
+                userIds
+                |> Seq.map (fun (UserId user) -> (newPostId, user))
+                |> Seq.toArray
+
+            let actual =
+                Seq.map (notifyNewPostSuccess (PostId newPostId)) userIds
+                |> Seq.sequenceTaskResultA
+
+            do! Expect.hasTaskOkValue expected actual |> Async.AwaitTask
+        }
+
+        testCaseAsync "sequenceTaskResultA with few invalid data"
+        <| async {
+            let expected = [|
+                sprintf "error: %s" (userId1.ToString())
+                sprintf "error: %s" (userId3.ToString())
+            |]
+
+            let! actual =
+                Seq.map (notifyFailure (PostId newPostId)) userIds
+                |> Seq.sequenceTaskResultA
+                |> Async.AwaitTask
+
+            let actual = Expect.wantError actual "Expected result to be Error"
+            Expect.equal actual expected "Should have a sequence of errors"
+        }
+    ]
+
 let traverseVOptionMTests =
     testList "Seq.traverseVOptionM Tests" [
         let tryTweetVOption x =
@@ -797,11 +906,13 @@ let allTests =
         traverseAsyncResultATests
         sequenceAsyncResultMTests
 #if !FABLE_COMPILER
+        traverseTaskResultATests
         sequenceTaskResultMTests
 #endif
         sequenceAsyncOptionMTests
         sequenceAsyncResultATests
 #if !FABLE_COMPILER
+        sequenceTaskResultATests
         traverseVOptionMTests
         sequenceVOptionMTests
 #endif