Revert to use uply

Author: Swoorup

src/FsToolkit.ErrorHandling.TaskResult/TaskOptionCE.fs

@@ -2,6 +2,7 @@ namespace FsToolkit.ErrorHandling
 
 open System
 open System.Threading.Tasks
+open FSharp.Control.Tasks.Affine.Unsafe
 open FSharp.Control.Tasks.Affine
 open Ply
 
@@ -10,12 +11,12 @@ module TaskOptionCE =
     type TaskOptionBuilder() =
         member inline _.Return (value: 'T)
           : Ply<Option<_>> =
-          task.Return <| option.Return value
+          uply.Return <| option.Return value
 
         member inline _.ReturnFrom
             (taskResult: Task<Option<_>>)
             : Ply<Option<_>> =
-          task.ReturnFrom taskResult
+          uply.ReturnFrom taskResult
 
         member inline this.ReturnFrom
             (asyncResult: Async<Option<_>>)
@@ -25,10 +26,10 @@ module TaskOptionCE =
         member inline _.ReturnFrom
             (result: Option<_>)
             : Ply<Option<_>> =
-          task.Return result
+          uply.Return result
 
         member inline _.Zero () : Ply<Option<_>> =
-          task.Return <| option.Zero()
+          uply.Return <| option.Zero()
 
         member inline _.Bind
             (taskResult: Task<Option<_>>,
@@ -37,8 +38,8 @@ module TaskOptionCE =
             let binder' r = 
               match r with
               | Some x -> binder x
-              | None -> task.Return None
-            task.Bind(taskResult, binder')
+              | None -> uply.Return None
+            uply.Bind(taskResult, binder')
 
         member inline this.Bind
             (asyncResult: Async<Option<_>>,
@@ -56,66 +57,63 @@ module TaskOptionCE =
 
         member inline _.Delay
             (generator: unit -> Ply<Option<_>>) =
-          task.Delay(generator)
+          uply.Delay(generator)
 
         member inline _.Combine
           (computation1: Ply<Option<'T>>,
            computation2: unit -> Ply<Option<'U>>)
-          : Ply<Option<'U>> =
-            task {
-              match! computation1 with
-              | None -> return None
-              | Some _ -> return! computation2()
-            } |> task.ReturnFrom
+          : Ply<Option<'U>> = uply {
+            match! computation1 with
+            | None -> return None
+            | Some _ -> return! computation2()
+          }
 
         member inline _.TryWith
             (computation: unit -> Ply<Option<_>>,
              handler: exn -> Ply<Option<_>>) :
              Ply<Option<_>> =
-             task.TryWith(computation, handler)
+             uply.TryWith(computation, handler)
 
         member inline _.TryFinally
             (computation: unit -> Ply<Option<_>>,
              compensation: unit -> unit)
             : Ply<Option<_>> =
-             task.TryFinally(computation, compensation)
+             uply.TryFinally(computation, compensation)
 
         member inline _.Using
             (resource: 'T when 'T :> IDisposable,
              binder: 'T -> Ply<Option<_>>)
             : Ply<Option<_>> =
-            task.Using(resource, binder)
+            uply.Using(resource, binder)
 
         member _.While
             (guard: unit -> bool, computation: unit -> Ply<Option<'U>>)
-            : Ply<Option<'U>> =
-              task {
-                let mutable fin, result = false, None
-                while not fin && guard() do
-                  match! computation() with
-                  | Some _ as o ->
-                    result <- o
-                  | None ->
-                    result <- None
-                    fin <- true
-                return result
-              } |> task.ReturnFrom
+            : Ply<Option<'U>> = uply {
+              let mutable fin, result = false, None
+              while not fin && guard() do
+                match! computation() with
+                | Some _ as o ->
+                  result <- o
+                | None ->
+                  result <- None
+                  fin <- true
+              return result
+            }
 
         member _.For
             (sequence: #seq<'T>, binder: 'T -> Ply<Option<'U>>)
-            : Ply<Option<'U>> =
-              task {
-                use enumerator = sequence.GetEnumerator()
-                let mutable fin, result = false, None
-                while not fin && enumerator.MoveNext() do
-                  match! binder enumerator.Current with
-                  | Some _ as o ->
-                    result <- o
-                  | None ->
-                    result <- None
-                    fin <- true
-                return result
-              } |> task.ReturnFrom
+            : Ply<Option<'U>> = uply {
+              use enumerator = sequence.GetEnumerator()
+              let mutable fin, result = false, None
+              while not fin && enumerator.MoveNext() do
+                match! binder enumerator.Current with
+                | Some _ as o ->
+                  result <- o
+                | None ->
+                  result <- None
+                  fin <- true
+              return result
+            }
 
         member inline _.Run(f : unit -> Ply<'m>) = task.Run f
 

src/FsToolkit.ErrorHandling.TaskResult/TaskResultCE.fs

@@ -2,6 +2,7 @@
 
 open System
 open System.Threading.Tasks
+open FSharp.Control.Tasks.Affine.Unsafe
 open FSharp.Control.Tasks.Affine
 open Ply
 
@@ -12,15 +13,15 @@ module TaskResultCE =
 
     member inline _.Return (value: 'T)
       : Ply<Result<'T,'TError>> =
-        task.Return (result.Return value)
+        uply.Return (result.Return value)
 
     member inline _.ReturnFrom
         (taskResult: Task<Result<'T, 'TError>>)
         : Ply<Result<'T, 'TError>> =
-          task.ReturnFrom taskResult
+          uply.ReturnFrom taskResult
 
     member inline _.Zero () : Ply<Result<unit, 'TError>> =
-      task.Return <| result.Zero()
+      uply.Return <| result.Zero()
 
     member inline _.Bind
         (taskResult: Task<Result<'T, 'TError>>,
@@ -29,69 +30,66 @@ module TaskResultCE =
         let binder' r = 
           match r with
           | Ok x -> binder x
-          | Error x -> task.Return <| Error x
-        task.Bind(taskResult, binder')
+          | Error x -> uply.Return <| Error x
+        uply.Bind(taskResult, binder')
 
     member inline _.Delay
         (generator: unit -> Ply<Result<'T, 'TError>>) =
-      task.Delay(generator)
+      uply.Delay(generator)
 
     member inline _.Combine
         (computation1: Ply<Result<unit, 'TError>>,
          computation2: unit -> Ply<Result<'U, 'TError>>)
-        : Ply<Result<'U, 'TError>> =
-          task {
-            match! computation1 with
-            | Error e -> return Error e
-            | Ok _ -> return! computation2()
-          } |> task.ReturnFrom
+        : Ply<Result<'U, 'TError>> = uply {
+          match! computation1 with
+          | Error e -> return Error e
+          | Ok _ -> return! computation2()
+        }
 
     member inline _.TryWith
         (computation: unit -> Ply<Result<'T, 'TError>>,
          handler: exn -> Ply<Result<'T, 'TError>>) :
          Ply<Result<'T, 'TError>> =
-      task.TryWith(computation, handler)
+      uply.TryWith(computation, handler)
 
     member inline _.TryFinally
         (computation: unit -> Ply<Result<'T, 'TError>>,
          compensation: unit -> unit)
         : Ply<Result<'T, 'TError>> =
-      task.TryFinally(computation, compensation)
+      uply.TryFinally(computation, compensation)
 
     member inline _.Using
         (resource: 'T when 'T :> IDisposable,
          binder: 'T -> Ply<Result<'U, 'TError>>)
         : Ply<Result<'U, 'TError>> =
-        task.Using(resource, binder)
+        uply.Using(resource, binder)
 
     member _.While
         (guard: unit -> bool, computation: unit -> Ply<Result<unit, 'TError>>)
-        : Ply<Result<unit, 'TError>> =
-          task {
-            let mutable fin, result = false, Ok()
-            while not fin && guard() do
-              match! computation() with
-              | Ok x -> x
-              | Error _ as e ->
-                result <- e
-                fin <- true
-            return result
-          } |> task.ReturnFrom
+        : Ply<Result<unit, 'TError>> = uply {
+          let mutable fin, result = false, Ok()
+          while not fin && guard() do
+            match! computation() with
+            | Ok x -> x
+            | Error _ as e ->
+              result <- e
+              fin <- true
+          return result
+        }
 
     member _.For
         (sequence: #seq<'T>, binder: 'T -> Ply<Result<unit, 'TError>>)
-        : Ply<Result<unit, 'TError>> =
-          task {
-            use enumerator = sequence.GetEnumerator()
-            let mutable fin, result = false, Ok()
-            while not fin && enumerator.MoveNext() do
-              match! binder enumerator.Current with
-              | Ok x -> x
-              | Error _ as e ->
-                result <- e
-                fin <- true
-            return result
-          } |> task.ReturnFrom
+        : Ply<Result<unit, 'TError>> = uply {
+          use enumerator = sequence.GetEnumerator()
+          let mutable fin, result = false, Ok()
+          while not fin && enumerator.MoveNext() do
+            match! binder enumerator.Current with
+            | Ok x -> x
+            | Error _ as e ->
+              result <- e
+              fin <- true
+          return result
+        }
 
     member inline this.BindReturn(x: Task<Result<'T,'U>>, f) = this.Bind(x, fun x -> this.Return(f x))
     member inline _.MergeSources(t1: Task<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = TaskResult.zip t1 t2

src/FsToolkit.ErrorHandling.TaskResult/TaskResultOptionCE.fs

@@ -1,6 +1,7 @@
 namespace FsToolkit.ErrorHandling
 
 open System.Threading.Tasks
+open FSharp.Control.Tasks.Affine.Unsafe
 open FSharp.Control.Tasks.Affine
 open Ply
 
@@ -10,12 +11,12 @@ module TaskResultOptionCE =
   type TaskResultOptionBuilder() =
     member inline _.Return (value: 'T)
       : Ply<Result<'T option,'TError>> =
-      task.Return <| result.Return (Some value)
+      uply.Return <| result.Return (Some value)
 
     member inline _.ReturnFrom
         (taskResult: Task<Result<'T option, 'TError>>)
         : Ply<Result<'T option, 'TError>> =
-      task.ReturnFrom taskResult
+      uply.ReturnFrom taskResult
 
     member inline _.Bind
         (taskResult: Task<Result<'T option, 'TError>>,
@@ -24,17 +25,17 @@ module TaskResultOptionCE =
         let binder' r = 
           match r with
           | Ok (Some x) -> binder x
-          | Ok None -> task.Return <| Ok None
-          | Error x -> task.Return <| Error x
-        task.Bind(taskResult, binder')
+          | Ok None -> uply.Return <| Ok None
+          | Error x -> uply.Return <| Error x
+        uply.Bind(taskResult, binder')
 
     member inline _.Combine(tro1, tro2) =
       tro1
       |> TaskResultOption.bind (fun _ -> tro2)
-      |> task.ReturnFrom
+      |> uply.ReturnFrom
 
     member inline _.Delay f =
-      task.Delay f
+      uply.Delay f
 
     member inline _.Run(f : unit -> Ply<'m>) = task.Run f