Canonicalize asyncOption CE type signatures

src/FsToolkit.ErrorHandling/AsyncOptionCE.fs

@@ -7,21 +7,21 @@ open System
 module AsyncOptionCE =
     type AsyncOptionBuilder() =
 
-        member __.Return (value: 'T) : Async<Option<_>> =
+        member __.Return (value: 'T) : Async<_ option> =
           async.Return <| option.Return value
 
         member __.ReturnFrom
-            (asyncResult: Async<Option<_>>)
-            : Async<Option<_>> =
+            (asyncResult: Async<_ option>)
+            : Async<_ option> =
           asyncResult
 
-        member __.Zero () : Async<Option<_>> =
+        member __.Zero () : Async<_ option> =
           async.Return <| option.Zero ()
 
         member inline __.Bind
-            (asyncResult: Async<Option<_>>,
-             binder: 'T -> Async<Option<_>>)
-            : Async<Option<_>> =
+            (asyncResult: Async<_ option>,
+             binder: 'T -> Async<_ option>)
+            : Async<_ option> =
           async {
             let! result = asyncResult
             match result with
@@ -30,46 +30,46 @@ module AsyncOptionCE =
           }
 
         member __.Delay
-            (generator: unit -> Async<Option<_>>)
-            : Async<Option<_>> =
+            (generator: unit -> Async<_ option>)
+            : Async<_ option> =
           async.Delay generator
 
         member this.Combine
-            (computation1: Async<Option<_>>,
-             computation2: Async<Option<_>>)
-            : Async<Option<_>> =
+            (computation1: Async<_ option>,
+             computation2: Async<_ option>)
+            : Async<_ option> =
           this.Bind(computation1, fun () -> computation2)
 
         member __.TryWith
-            (computation: Async<Option<_>>,
-             handler: System.Exception -> Async<Option<_>>)
-            : Async<Option<_>> =
+            (computation: Async<_ option>,
+             handler: System.Exception -> Async<_ option>)
+            : Async<_ option> =
           async.TryWith(computation, handler)
 
         member __.TryFinally
-            (computation: Async<Option<_>>,
+            (computation: Async<_ option>,
              compensation: unit -> unit)
-            : Async<Option<_>> =
+            : Async<_ option> =
           async.TryFinally(computation, compensation)
 
         member __.Using
             (resource: 'T when 'T :> IDisposable,
-             binder: 'T -> Async<Option<_>>)
-            : Async<Option<_>> =
+             binder: 'T -> Async<_ option>)
+            : Async<_ option> =
             __.TryFinally (
                 (binder resource),
                 (fun () -> if not <| obj.ReferenceEquals(resource, null) then resource.Dispose ())
             )
 
         member this.While
-            (guard: unit -> bool, computation: Async<Option<_>>)
-            : Async<Option<_>> =
+            (guard: unit -> bool, computation: Async<_ option>)
+            : Async<_ option> =
           if not <| guard () then this.Zero ()
           else this.Bind(computation, fun () -> this.While (guard, computation))
 
         member this.For
-            (sequence: #seq<'T>, binder: 'T -> Async<Option<_>>)
-            : Async<Option<_>> =
+            (sequence: #seq<'T>, binder: 'T -> Async<_ option>)
+            : Async<_ option> =
           this.Using(sequence.GetEnumerator (), fun enum ->
             this.While(enum.MoveNext,
               this.Delay(fun () -> binder enum.Current)))
@@ -79,13 +79,13 @@ module AsyncOptionCE =
         ///
         /// 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
+        member inline _.Source(async : Async<_ option>) : Async<_ option> = async
 
 #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
+        member inline _.Source(task : Task<_ option>) : Async<_ option> = task |> Async.AwaitTask
 #endif
 
     let asyncOption = AsyncOptionBuilder() 
@@ -105,7 +105,7 @@ module AsyncOptionCEExtensions =
     /// <summary>
     /// Method lets us transform data types into our internal representation.
     /// </summary>
-    member inline __.Source(r: Option<'t>) = Async.singleton r
+    member inline __.Source(r: 't option) = Async.singleton r
     /// <summary>
     /// Method lets us transform data types into our internal representation.
     /// </summary>
@@ -116,4 +116,4 @@ module AsyncOptionCEExtensions =
     /// Method lets us transform data types into our internal representation.
     /// </summary>
     member inline __.Source(a: Task<'t>) = a |> Async.AwaitTask |> Async.map Some
-#endif
+#endif