Converted AsyncOptionCE to use Source overload and added Async/Task

Author: Jmaharman

src/FsToolkit.ErrorHandling/AsyncOptionCE.fs

@@ -15,22 +15,10 @@ module AsyncOptionCE =
             : Async<Option<_>> =
           asyncResult
 
-        #if !FABLE_COMPILER
-        member __.ReturnFrom
-            (taskResult: Task<Option<_>>)
-            : Async<Option<_>> =
-          Async.AwaitTask taskResult
-        #endif
-
-        member __.ReturnFrom
-            (result: Option<_>)
-            : Async<Option<_>> =
-          async.Return result
-
         member __.Zero () : Async<Option<_>> =
           async.Return <| option.Zero ()
 
-        member __.Bind
+        member inline __.Bind
             (asyncResult: Async<Option<_>>,
              binder: 'T -> Async<Option<_>>)
             : Async<Option<_>> =
@@ -41,20 +29,6 @@ module AsyncOptionCE =
             | None -> return None
           }
 
-        #if !FABLE_COMPILER
-        member this.Bind
-            (taskResult: Task<Option<_>>,
-             binder: 'T -> Async<Option<_>>)
-            : Async<Option<_>> =
-          this.Bind(Async.AwaitTask taskResult, binder)
-        #endif
-
-        member this.Bind
-            (result: Option<_>, binder: 'T -> Async<Option<_>>)
-            : Async<Option<_>> =
-          this.Bind(this.ReturnFrom result, binder)
-
-
         member __.Delay
             (generator: unit -> Async<Option<_>>)
             : Async<Option<_>> =
@@ -100,5 +74,46 @@ module AsyncOptionCE =
             this.While(enum.MoveNext,
               this.Delay(fun () -> binder enum.Current)))
 
+        /// <summary>
+        /// Method lets us transform data types into our internal representation. This is the identity method to recognize the self type.
+        ///
+        /// See https://stackoverflow.com/questions/35286541/why-would-you-use-builder-source-in-a-custom-computation-expression-builder
+        /// </summary>
+        member inline _.Source(async : Async<Option<_>>) : Async<Option<_>> = async
 
-    let asyncOption = AsyncOptionBuilder() 
+#if !FABLE_COMPILER
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.  
+        /// </summary>
+        member inline _.Source(task : Task<Option<_>>) : Async<Option<_>> = task |> Async.AwaitTask
+#endif
+
+    let asyncOption = AsyncOptionBuilder() 
+
+
+[<AutoOpen>]
+// Having members as extensions gives them lower priority in
+// overload resolution and allows skipping more type annotations.
+module AsyncOptionCEExtensions =
+
+   type AsyncOptionBuilder with
+    /// <summary>
+    /// Needed to allow `for..in` and `for..do` functionality
+    /// </summary>
+    member inline __.Source(s: #seq<_>) = s
+
+    /// <summary>
+    /// Method lets us transform data types into our internal representation.
+    /// </summary>
+    member inline __.Source(r: Option<'t>) = Async.singleton r
+    /// <summary>
+    /// Method lets us transform data types into our internal representation.
+    /// </summary>
+    member inline __.Source(a: Async<'t>) = a |> Async.map Some
+
+#if !FABLE_COMPILER
+    /// <summary>
+    /// Method lets us transform data types into our internal representation.
+    /// </summary>
+    member inline __.Source(a: Task<'t>) = a |> Async.AwaitTask |> Async.map Some
+#endif

tests/FsToolkit.ErrorHandling.Tests/AsyncOptionCE.fs

@@ -44,6 +44,13 @@ let ceTests =
             }
             Expect.equal actual expected "Should return value wrapped in option"
         }
+        testCaseAsync "ReturnFrom Async" <| async {
+            let expected = Some 42
+            let! actual = asyncOption  {
+                return! async { return 42 }
+            }
+            Expect.equal actual expected "Should return value wrapped in option"
+        }
 
         #if !FABLE_COMPILER
         testCaseAsync "ReturnFrom Task None" <| async {
@@ -53,6 +60,13 @@ let ceTests =
             }
             Expect.equal actual expected "Should return value wrapped in option"
         }
+        testCaseAsync "ReturnFrom Task" <| async {
+            let expected = Some 42
+            let! actual = asyncOption  {
+                return! (Task.FromResult 42)
+            }
+            Expect.equal actual expected "Should return value wrapped in option"
+        }
         #endif
         testCaseAsync "Bind Some" <| async {
             let expected = Some 42
@@ -78,6 +92,14 @@ let ceTests =
             }
             Expect.equal actual expected "Should bind value wrapped in option"
         }
+        testCaseAsync "Bind Async" <| async {
+            let expected = Some 42
+            let! actual = asyncOption {
+                let! value = async.Return(42)
+                return value
+            }
+            Expect.equal actual expected "Should bind value wrapped in option"
+        }
 
         #if !FABLE_COMPILER
         testCaseAsync "Bind Task None" <| async {
@@ -88,6 +110,14 @@ let ceTests =
             }
             Expect.equal actual expected "Should bind value wrapped in option"
         }
+        testCaseAsync "Bind Task" <| async {
+            let expected = Some 42
+            let! actual = asyncOption {
+                let! value = Task.FromResult 42
+                return value
+            }
+            Expect.equal actual expected "Should bind value wrapped in option"
+        }
         #endif
 
         testCaseAsync "Zero/Combine/Delay/Run" <| async {