Fixed #86

Allows for binding the outer async for complex workflows

Author: Jimmy Byrd

src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs

@@ -151,4 +151,12 @@ module JobResultCEExtensions =
     /// Method lets us transform data types into our internal representation.
     /// </summary>
     member inline _.Source(t : Task) : Job<Result<_,_>> = t |> Job.awaitUnitTask |> Job.map Ok
-    
+    
+    member inline __.Bind(asyncComputation: Async<_>,  binder: 'T -> Job<Result<'U, 'TError>>) : Job<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Async.map Ok |> Job.fromAsync, binder)
+
+    member inline __.Bind(asyncComputation: Task<_>,  binder: 'T -> Job<Result<'U, 'TError>>) : Job<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Task.map Ok |> Job.awaitTask, binder)
+
+    member inline __.Bind(asyncComputation: Job<_>,  binder: 'T -> Job<Result<'U, 'TError>>) : Job<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Job.map Ok, binder)

src/FsToolkit.ErrorHandling.TaskResult/TaskResultCE.fs

@@ -68,6 +68,9 @@ module TaskResultCE =
           | Error x -> ret <| Error x
         bindTaskConfigureFalse taskResult binder'
 
+
+
+
     member __.Delay
         (generator: unit -> Step<Result<'T, 'TError>>) =
       task.Delay(generator)
@@ -161,3 +164,9 @@ module TaskResultCEExtensions =
     /// Method lets us transform data types into our internal representation.
     /// </summary>
     member inline _.Source(t : Task) : Task<Result<_,_>> = task { return! t } |> Task.map Ok
+
+    member inline __.Bind(asyncComputation: Async<_>,  binder: 'T -> Step<Result<'U, 'TError>>) : Step<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Async.map Ok |> Async.StartAsTask, binder)
+
+    member inline __.Bind(asyncComputation: Task<_>,  binder: 'T -> Step<Result<'U, 'TError>>) : Step<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Task.map Ok, binder)

src/FsToolkit.ErrorHandling/AsyncResultCE.fs

@@ -121,6 +121,10 @@ module AsyncResultCEExtensions =
     /// </summary>
     member inline __.Source(asyncComputation : Async<_>) : Async<Result<_,_>> = asyncComputation |> Async.map Ok
 
+
+    member inline __.Bind(asyncComputation: Async<_>,  binder: 'T -> Async<Result<'U, 'TError>>) : Async<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Async.map Ok, binder)
+
 #if !FABLE_COMPILER
     /// <summary>
     /// Method lets us transform data types into our internal representation.
@@ -131,4 +135,8 @@ module AsyncResultCEExtensions =
     /// Method lets us transform data types into our internal representation.
     /// </summary>
     member inline _.Source(task : Task) : Async<Result<_,_>> =task |> Async.AwaitTask |> Async.map Ok
+
+
+    member inline __.Bind(asyncComputation: Task<_>,  binder: 'T -> Async<Result<'U, 'TError>>) : Async<Result<'U, 'TError>> =
+      __.Bind(asyncComputation |> Async.AwaitTask |> Async.map Ok, binder)
 #endif

tests/FsToolkit.ErrorHandling.JobResult.Tests/JobResultCE.fs

@@ -146,6 +146,32 @@ let ``JobResultCE bind Tests`` =
 
             Expect.equal actual (Result.Ok ()) "Should be ok"
         }
+        testCaseJob "Let! outer Async wrapper" <| job {
+            let innerData = "Foo"
+            let! f = jobResult {
+                let! (r : Result<_,_>) = AsyncResult.retn innerData
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
+
+        testCaseJob "Let! outer Task wrapper" <| job {
+            let innerData = "Foo"
+            let! f = jobResult {
+                let! (r : Result<_,_>) = Task.FromResult(Ok innerData)
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
+
+        testCaseJob "Let! outer Job wrapper" <| job {
+            let innerData = "Foo"
+            let! f = jobResult {
+                let! (r : Result<_,_>) = Job.result (Ok innerData)
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
     ]
 
 

tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResultCE.fs

@@ -142,6 +142,23 @@ let ``TaskResultCE bind Tests`` =
 
             Expect.equal actual (Result.Ok ()) "Should be ok"
         }
+        testCaseTask "Let! outer Async wrapper" <| task {
+            let innerData = "Foo"
+            let! f = taskResult {
+                let! (r : Result<_,_>) = AsyncResult.retn innerData
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
+
+        testCaseTask "Let! outer Task wrapper" <| task {
+            let innerData = "Foo"
+            let! f = taskResult {
+                let! (r : Result<_,_>) = Task.FromResult(Ok innerData)
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
     ]
 
 

tests/FsToolkit.ErrorHandling.Tests/AsyncResultCE.fs

@@ -90,8 +90,8 @@ let ``AsyncResultCE bind Tests`` =
                 return data 
             }        
             Expect.equal actual (data) "Should be ok"
-
         }
+
         testCaseAsync "Bind Ok Choice" <| async {
             let innerData = "Foo"
             let data = Choice1Of2 innerData
@@ -113,6 +113,7 @@ let ``AsyncResultCE bind Tests`` =
             Expect.equal actual (data) "Should be ok"
         }
 
+      
         testCaseAsync "Bind Async" <| async {
             let innerData = "Foo"
             let d = Async.singleton innerData
@@ -124,6 +125,15 @@ let ``AsyncResultCE bind Tests`` =
             Expect.equal actual (Result.Ok innerData) "Should be ok"
         }
 
+        testCaseAsync "Let! outer Async wrapper" <| async {
+            let innerData = "Foo"
+            let! f = asyncResult {
+                let! (r : Result<_,_>) = AsyncResult.retn innerData
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
+
 
         #if !FABLE_COMPILER        
         testCaseAsync "Bind Ok TaskResult" <| async {
@@ -153,6 +163,15 @@ let ``AsyncResultCE bind Tests`` =
 
             Expect.equal actual (Result.Ok ()) "Should be ok"
         }
+
+        testCaseAsync "Let! outer Task wrapper" <| async {
+            let innerData = "Foo"
+            let! f = asyncResult {
+                let! (r : Result<_,_>) = Task.FromResult(Ok innerData)
+                Expect.equal r (Ok innerData) "Should be ok"
+            }
+            ()
+        }
         #endif
     ]