Enable try blocks for ValueTask

Author: gusty

src/FSharpPlus/Control/Monad.fs

@@ -217,6 +217,7 @@ type TryWith =
     static member        TryWith (computation: unit -> Async<_>      , catchHandler: exn -> Async<_>      , _: TryWith , _) = async.TryWith ((computation ()), catchHandler)
     #if !FABLE_COMPILER
     static member        TryWith (computation: unit -> Task<_>       , catchHandler: exn -> Task<_>       , _: TryWith, True) = Task.tryWith computation catchHandler
+    static member        TryWith (computation: unit -> ValueTask<_>  , catchHandler: exn -> ValueTask<_>  , _: TryWith, True) = ValueTask.tryWith catchHandler computation
     #endif
     static member        TryWith (computation: unit -> Lazy<_>       , catchHandler: exn -> Lazy<_>       , _: TryWith , _) = lazy (try (computation ()).Force () with e -> (catchHandler e).Force ()) : Lazy<_>
 
@@ -245,7 +246,8 @@ type TryFinally =
     static member        TryFinally ((computation: unit -> Id<_>   , compensation: unit -> unit), _: TryFinally, _, _) = try computation () finally compensation ()
     static member        TryFinally ((computation: unit -> Async<_>, compensation: unit -> unit), _: TryFinally, _, _) = async.TryFinally (computation (), compensation) : Async<_>
     #if !FABLE_COMPILER
-    static member        TryFinally ((computation: unit -> Task<_> , compensation: unit -> unit), _: TryFinally, _, True) = Task.tryFinally computation compensation : Task<_>
+    static member        TryFinally ((computation: unit -> Task<_>     , compensation: unit -> unit), _: TryFinally, _, True) = Task.tryFinally computation compensation : Task<_>
+    static member        TryFinally ((computation: unit -> ValueTask<_>, compensation: unit -> unit), _: TryFinally, _, True) = ValueTask.tryFinally compensation computation : ValueTask<_>
     #endif
     static member        TryFinally ((computation: unit -> Lazy<_> , compensation: unit -> unit), _: TryFinally, _, _) = lazy (try (computation ()).Force () finally compensation ()) : Lazy<_>
 
@@ -281,7 +283,8 @@ type Using =
     static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> 'R -> 'U , _: Using   ) = (fun s -> try body resource s finally if not (isNull (box resource)) then resource.Dispose ()) : 'R->'U
     static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> Async<'U>, _: Using   ) = async.Using (resource, body)
     #if !FABLE_COMPILER
-    static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> Task<'U>, _: Using    ) = Task.using resource body
+    static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> Task<'U>     , _: Using) = Task.using resource body
+    static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> ValueTask<'U>, _: Using) = ValueTask.using resource body
     #endif
     static member        Using (resource: 'T when 'T :> IDisposable, body: 'T -> Lazy<'U> , _: Using   ) = lazy (try (body resource).Force () finally if not (isNull (box resource)) then resource.Dispose ()) : Lazy<'U>
 

src/FSharpPlus/Extensions/ValueTask.fs

@@ -243,6 +243,58 @@ module ValueTask =
                 else source.ConfigureAwait(false).GetAwaiter().UnsafeOnCompleted (fun () -> k source)
             tcs.Task |> ValueTask<unit>
 
+    /// Used to de-sugar try .. with .. blocks in Computation Expressions.
+    let inline tryWith ([<InlineIfLambda>]compensation: exn -> ValueTask<'T>) ([<InlineIfLambda>]body: unit -> ValueTask<'T>) : ValueTask<'T> =
+        let unwrapException (agg: AggregateException) =
+            if agg.InnerExceptions.Count = 1 then agg.InnerExceptions.[0]
+            else agg :> Exception
+        try
+            let task = body ()
+            if task.IsCompleted then
+                match task with
+                | Succeeded _ -> task
+                | Faulted exn -> compensation (unwrapException exn)
+                | Canceled    -> compensation (TaskCanceledException ())
+            else
+                let tcs = TaskCompletionSource<'T> ()
+                let f = function
+                    | Succeeded r -> tcs.SetResult r
+                    | Faulted exn -> continueTask tcs (compensation (unwrapException exn))      (fun r -> try tcs.SetResult r with e -> tcs.SetException e)
+                    | Canceled    -> continueTask tcs (compensation (TaskCanceledException ())) (fun r -> try tcs.SetResult r with e -> tcs.SetException e)
+                task.ConfigureAwait(false).GetAwaiter().UnsafeOnCompleted (fun () -> f task)
+                ValueTask<'T> tcs.Task
+        with
+        | :? AggregateException as exn -> compensation (unwrapException exn)
+        | exn                          -> compensation exn
+    
+    /// Used to de-sugar try .. finally .. blocks in Computation Expressions.
+    let inline tryFinally ([<InlineIfLambda>]compensation : unit -> unit) ([<InlineIfLambda>]body: unit -> ValueTask<'T>) : ValueTask<'T> =
+        let mutable ran = false
+        let compensation () =
+            if not ran then
+                compensation ()
+                ran <- true
+        try
+            let task = body ()
+            if task.IsCompleted then compensation (); task
+            else
+                let tcs = TaskCompletionSource<'T> ()
+                let f = function
+                | Succeeded r -> tcs.SetResult r
+                | Faulted exn -> tcs.SetException exn.InnerExceptions
+                | Canceled    -> tcs.SetCanceled ()
+                task.ConfigureAwait(false).GetAwaiter().UnsafeOnCompleted (fun () -> compensation (); f task)
+                ValueTask<'T> tcs.Task
+        with _ ->
+            compensation ()
+            reraise ()
+
+    /// Used to de-sugar use .. blocks in Computation Expressions.
+    let inline using (disp: 'T when 'T :> IDisposable) ([<InlineIfLambda>]body: 'T -> ValueTask<'U>) =
+        tryFinally
+            (fun () -> if not (isNull (box disp)) then disp.Dispose ())
+            (fun () -> body disp)
+
 
     /// Raises an exception in the ValueTask
     let raise<'TResult> (``exception``: exn) = ValueTask<'TResult> (Task.FromException<'TResult> ``exception``)