Revert "Fixed #86"

This reverts commit 9ee69d0.

Author: TheAngryByrd

src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs

@@ -151,12 +151,4 @@ 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,9 +68,6 @@ module TaskResultCE =
           | Error x -> ret <| Error x
         bindTaskConfigureFalse taskResult binder'
 
-
-
-
     member __.Delay
         (generator: unit -> Step<Result<'T, 'TError>>) =
       task.Delay(generator)
@@ -164,9 +161,3 @@ 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,10 +121,6 @@ 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.
@@ -135,8 +131,4 @@ 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,32 +146,6 @@ 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,23 +142,6 @@ 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,7 +113,6 @@ let ``AsyncResultCE bind Tests`` =
             Expect.equal actual (data) "Should be ok"
         }
 
-      
         testCaseAsync "Bind Async" <| async {
             let innerData = "Foo"
             let d = Async.singleton innerData
@@ -125,15 +124,6 @@ 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 {
@@ -163,15 +153,6 @@ 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
     ]