diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md
index 97c667e0eb3..6904710cc82 100644
--- a/docs/release-notes/.FSharp.Core/11.0.100.md
+++ b/docs/release-notes/.FSharp.Core/11.0.100.md
@@ -8,3 +8,5 @@
 ### Added
 
 * `Async.RunSynchronouslyImmediate`: runs work on the calling thread until the first asynchronous suspension (as opposed to `RunSynchronously`, which immediately offloads if not on a background and/or threadpool thread). ([Issue #1042](https://github.com/fsharp/fslang-suggestions/issues/1042), [PR #19804](https://github.com/dotnet/fsharp/pull/19804))
+* Added modules for `Async`, `Task` and `ValueTask` with consistent `result`, `map`, `bind`, `ignore`, `catchWith`, `catch`, and `empty` functions ([LanguageSuggestion #1466](https://github.com/fsharp/fslang-suggestions/issues/1466), [PR #19844](https://github.com/dotnet/fsharp/pull/19844))
+* Added conversion functions `Task.ofValueTask` and `ValueTask.ofTask`. ([LanguageSuggestion #1466](https://github.com/fsharp/fslang-suggestions/issues/1466), [PR #19844](https://github.com/dotnet/fsharp/pull/19844))
diff --git a/src/FSharp.Core/async.fs b/src/FSharp.Core/async.fs
index 02994a3a886..73c004b4260 100644
--- a/src/FSharp.Core/async.fs
+++ b/src/FSharp.Core/async.fs
@@ -2354,3 +2354,45 @@ module WebExtensions =
                 start = (fun userToken -> this.DownloadFileAsync(address, fileName, userToken)),
                 result = (fun _ -> ())
             )
+
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module Async =
+
+    [<CompiledName("Result")>]
+    let inline result (value: 'T) : Async<'T> =
+        async.Return value
+
+    [<CompiledName("Map")>]
+    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (computation: Async<'T>) : Async<'U> =
+        async.Bind(computation, mapping >> async.Return)
+
+    [<CompiledName("Bind")>]
+    let inline bind ([<InlineIfLambda>] binder: 'T -> Async<'U>) (computation: Async<'T>) : Async<'U> =
+        async.Bind(computation, binder)
+
+    [<CompiledName("Ignore")>]
+    [<RequiresExplicitTypeArguments>]
+    let inline ignore<'T> (computation: Async<'T>) : Async<unit> =
+        Async.Ignore computation
+
+    [<CompiledName("CatchWith")>]
+    let catchWith (handler: exn -> 'T) (computation: Async<'T>) : Async<'T> =
+        async {
+            try
+                return! computation
+            with e ->
+                return handler e
+        }
+
+    [<CompiledName("Catch")>]
+    let catch (computation: Async<'T>) : Async<Result<'T, exn>> =
+        async {
+            try
+                let! v = computation
+                return Result.Ok v
+            with e ->
+                return Result.Error e
+        }
+
+    [<CompiledName("Empty")>]
+    let empty: Async<unit> = async.Zero()
diff --git a/src/FSharp.Core/async.fsi b/src/FSharp.Core/async.fsi
index a629ab50fc5..1af0fab84db 100644
--- a/src/FSharp.Core/async.fsi
+++ b/src/FSharp.Core/async.fsi
@@ -1006,7 +1006,7 @@ namespace Microsoft.FSharp.Control
         ///         use file = System.IO.File.OpenRead(filename)
         ///         printfn "Reading from file %s." filename
         ///         // Throw away the data being read.
-        ///         do! file.AsyncRead(numBytes) |> Async.Ignore
+        ///         do! file.AsyncRead(numBytes) |> Async.ignore&lt;byte[]&gt;
         ///     }
         /// readFile "example.txt" 42 |> Async.Start
         /// </code>
@@ -1584,3 +1584,131 @@ namespace Microsoft.FSharp.Control
     module internal AsyncBuilderImpl = 
         val async : AsyncBuilder
 
+    /// <summary>Contains camelCase module-level functions for <see cref="T:Microsoft.FSharp.Control.FSharpAsync`1"/> computations.</summary>
+    ///
+    /// <category index="1">Async Programming</category>
+    [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+    module Async =
+
+        /// <summary>Creates an asynchronous computation that returns the given value.</summary>
+        ///
+        /// <param name="value">The value to return.</param>
+        ///
+        /// <returns>An asynchronous computation that returns <c>value</c> when executed.</returns>
+        ///
+        /// <example id="async-result-1">
+        /// <code lang="fsharp">
+        /// let computation = Async.result 42
+        /// computation |> Async.RunSynchronouslyImmediate // evaluates to 42
+        /// </code>
+        /// </example>
+        [<CompiledName("Result")>]
+        val inline result: value: 'T -> Async<'T>
+
+        /// <summary>Creates an asynchronous computation that applies the mapping function to the result of the given computation.</summary>
+        ///
+        /// <param name="mapping">The function to apply to the result.</param>
+        /// <param name="computation">The input computation.</param>
+        ///
+        /// <returns>An asynchronous computation that applies <c>mapping</c> to the result of <c>computation</c>.</returns>
+        ///
+        /// <example id="async-map-1">
+        /// <code lang="fsharp">
+        /// let computation = Async.result 21 |> Async.map (fun x -> x * 2)
+        /// computation |> Async.RunSynchronouslyImmediate // evaluates to 42
+        /// </code>
+        /// </example>
+        [<CompiledName("Map")>]
+        val inline map: mapping: ('T -> 'U) -> computation: Async<'T> -> Async<'U>
+
+        /// <summary>Creates an asynchronous computation that passes the result of the given computation to the binder function.</summary>
+        ///
+        /// <param name="binder">A function that takes the result of the computation and returns a new asynchronous computation.</param>
+        /// <param name="computation">The input computation.</param>
+        ///
+        /// <returns>An asynchronous computation that performs a monadic bind on the result of <c>computation</c>.</returns>
+        ///
+        /// <example id="async-bind-1">
+        /// <code lang="fsharp">
+        /// let computation = Async.result 21 |> Async.bind (fun x -> Async.result (x * 2))
+        /// computation |> Async.RunSynchronouslyImmediate // evaluates to 42
+        /// </code>
+        /// </example>
+        [<CompiledName("Bind")>]
+        val inline bind: binder: ('T -> Async<'U>) -> computation: Async<'T> -> Async<'U>
+
+        /// <summary>Creates an asynchronous computation that runs the given computation and ignores its result.</summary>
+        ///
+        /// <param name="computation">The input computation.</param>
+        ///
+        /// <returns>A computation that is equivalent to the input computation, but disregards the result.</returns>
+        ///
+        /// <example id="async-ignore-1">
+        /// <code lang="fsharp">
+        /// let readFile filename numBytes: Async&lt;unit&gt; =
+        ///     async {
+        ///         use file = System.IO.File.OpenRead(filename)
+        ///         do! file.AsyncRead(numBytes) |> Async.ignore&lt;byte[]&gt;
+        ///     }
+        /// </code>
+        /// </example>
+        /// <example id="async-ignore-2">
+        /// <code lang="fsharp">
+        /// let computation : Async&lt;unit&gt; = Async.result 42 |> Async.ignore&lt;int&gt;
+        /// computation |> Async.RunSynchronously // evaluates to ()
+        /// </code>
+        /// </example>
+        [<CompiledName("Ignore")>]
+        [<RequiresExplicitTypeArguments>]
+        val inline ignore<'T> : computation: Async<'T> -> Async<unit>
+
+        /// <summary>Creates an asynchronous computation that yields the original result on success, or the result of
+        /// <c>handler exn</c> for non-cancellation exceptions.</summary>
+        /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged,
+        /// and therefore are never passed to <c>handler</c>.
+        /// </remarks>
+        /// <param name="handler">A function to handle (non-cancellation) exceptions, yielding a recovery value based on the exception.
+        /// Any exception thrown by <c>handler</c> will propagate.</param>
+        /// <param name="computation">The input computation.</param>
+        /// <returns>An asynchronous computation that yields the result of <c>computation</c> on success,
+        /// or <c>handler exn</c> on failure.
+        /// Propagates the underlying cancellation exception where cancellation occurs.</returns>
+        /// <example id="async-catchwith-1">
+        /// <code lang="fsharp">
+        /// let safeDiv x y =
+        ///     async { return x / y }
+        ///     |> Async.catchWith (fun _ -> 0)
+        /// safeDiv 10 0 |> Async.RunSynchronouslyImmediate // evaluates to 0
+        /// </code>
+        /// </example>
+        [<CompiledName("CatchWith")>]
+        val catchWith: handler: (exn -> 'T) -> computation: Async<'T> -> Async<'T>
+
+        /// <summary>Creates an asynchronous computation that reifies the outcome of the given <c>computation</c> as a <c>Result</c>:
+        /// <c>Ok</c> on success, <c>Error</c> on failure, so exceptions become values. Cancellation still propagates.</summary>
+        /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged.</remarks>
+        /// <param name="computation">The input computation.</param>
+        /// <returns>An asynchronous computation that yields a <c>Result</c>: <c>Ok</c> with the outcome on success,
+        /// or <c>Error</c> with the exception on failure.
+        /// Propagates the underlying cancellation exception when cancellation occurs.</returns>
+        /// <example id="async-catch-1">
+        /// <code lang="fsharp">
+        /// let safeDiv x y =
+        ///     async { return x / y } |> Async.catch
+        /// safeDiv 10 2 |> Async.RunSynchronouslyImmediate // evaluates to Ok 5
+        /// safeDiv 10 0 |> Async.RunSynchronouslyImmediate // evaluates to Error (DivideByZeroException ...)
+        /// </code>
+        /// </example>
+        [<CompiledName("Catch")>]
+        val catch: computation: Async<'T> -> Async<Result<'T, exn>>
+
+        /// <summary>An asynchronous computation that returns <c>unit</c>. This is equivalent to <c>async.Zero()</c>.</summary>
+        ///
+        /// <example id="async-empty-1">
+        /// <code lang="fsharp">
+        /// Async.empty |> Async.RunSynchronouslyImmediate // evaluates to ()
+        /// </code>
+        /// </example>
+        [<CompiledName("Empty")>]
+        val empty: Async<unit>
+
diff --git a/src/FSharp.Core/tasks.fs b/src/FSharp.Core/tasks.fs
index eec12a86c63..eda1d005c83 100644
--- a/src/FSharp.Core/tasks.fs
+++ b/src/FSharp.Core/tasks.fs
@@ -716,3 +716,154 @@ module LowPlusPriority =
                         this.Bind(computation, fun (result2: ^TResult2) -> this.Return struct (result1, result2))
                 )
             )
+
+namespace Microsoft.FSharp.Control
+
+open System.Threading.Tasks
+open Microsoft.FSharp.Core
+open TaskBuilder
+open Microsoft.FSharp.Control.TaskBuilderExtensions
+open Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority
+open Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority
+
+[<RequireQualifiedAccess>]
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module Task =
+
+    [<CompiledName("Result")>]
+    let inline result (value: 'T) : Task<'T> =
+        Task.FromResult value
+
+    [<CompiledName("Empty")>]
+    let empty: Task<unit> = result ()
+
+    [<CompiledName("Bind")>]
+    let inline bind ([<InlineIfLambda>] binder: 'T -> Task<'U>) (task: Task<'T>) : Task<'U> =
+        if task.Status = TaskStatus.RanToCompletion then
+            try
+                binder task.Result
+            with e ->
+                Task.FromException<'U>(e)
+        else
+            TaskBuilder.task {
+                let! v = task
+                return! binder v
+            }
+
+    [<CompiledName("Map")>]
+    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (task: Task<'T>) : Task<'U> =
+        if task.Status = TaskStatus.RanToCompletion then
+            try
+                mapping task.Result |> result
+            with e ->
+                Task.FromException<'U>(e)
+        else
+            TaskBuilder.task {
+                let! v = task
+                return mapping v
+            }
+
+    [<CompiledName("Ignore")>]
+    [<RequiresExplicitTypeArguments>]
+    let inline ignore<'T> (task: Task<'T>) : Task<unit> =
+        if task.Status = TaskStatus.RanToCompletion then
+            empty
+        else
+            map ignore task
+
+    [<CompiledName("CatchWith")>]
+    let inline catchWith ([<InlineIfLambda>] handler: exn -> 'T) (task: Task<'T>) : Task<'T> =
+        if task.Status = TaskStatus.RanToCompletion then
+            task
+        else
+            TaskBuilder.task {
+                try
+                    return! task
+                with
+                | :? System.OperationCanceledException as e -> return! raise e
+                | e -> return handler e
+            }
+
+    [<CompiledName("Catch")>]
+    let catch (task: Task<'T>) : Task<Result<'T, exn>> =
+        task |> map Ok |> catchWith Error
+
+#if NETSTANDARD2_1
+    [<CompiledName("OfValueTask")>]
+    let inline ofValueTask (valueTask: ValueTask<'T>) : Task<'T> =
+        valueTask.AsTask()
+#endif
+
+#if NETSTANDARD2_1
+[<RequireQualifiedAccess>]
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module ValueTask =
+
+    [<CompiledName("Result")>]
+    let inline result (value: 'T) : ValueTask<'T> =
+        ValueTask<'T>(value)
+
+    [<CompiledName("Empty")>]
+    let empty: ValueTask<unit> = result ()
+
+    [<CompiledName("OfTask")>]
+    let inline ofTask (task: Task<'T>) : ValueTask<'T> =
+        ValueTask<'T>(task)
+
+    [<CompiledName("Bind")>]
+    let inline bind ([<InlineIfLambda>] binder: 'T -> ValueTask<'U>) (task: ValueTask<'T>) : ValueTask<'U> =
+        if task.IsCompletedSuccessfully then
+            try
+                binder task.Result
+            with e ->
+                Task.FromException<'U>(e) |> ofTask
+        else
+            let t: Task<'U> =
+                TaskBuilder.task {
+                    let! v = task
+                    return! binder v
+                }
+
+            ValueTask<'U>(t)
+
+    [<CompiledName("Map")>]
+    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (task: ValueTask<'T>) : ValueTask<'U> =
+        if task.IsCompletedSuccessfully then
+            try
+                mapping task.Result |> result
+            with e ->
+                Task.FromException<'U>(e) |> ofTask
+        else
+            let t: Task<'U> =
+                TaskBuilder.task {
+                    let! v = task
+                    return mapping v
+                }
+
+            ValueTask<'U>(t)
+
+    [<CompiledName("Ignore")>]
+    [<RequiresExplicitTypeArguments>]
+    let inline ignore<'T> (task: ValueTask<'T>) : ValueTask<unit> =
+        map ignore task
+
+    [<CompiledName("CatchWith")>]
+    let inline catchWith ([<InlineIfLambda>] handler: exn -> 'T) (task: ValueTask<'T>) : ValueTask<'T> =
+        if task.IsCompletedSuccessfully then
+            task
+        else
+            let t: Task<'T> =
+                TaskBuilder.task {
+                    try
+                        return! task
+                    with
+                    | :? System.OperationCanceledException as e -> return! raise e
+                    | e -> return handler e
+                }
+
+            ValueTask<'T>(t)
+
+    [<CompiledName("Catch")>]
+    let catch (task: ValueTask<'T>) : ValueTask<Result<'T, exn>> =
+        task |> map Ok |> catchWith Error
+#endif
diff --git a/src/FSharp.Core/tasks.fsi b/src/FSharp.Core/tasks.fsi
index 76d84bcfd28..a4e6806d824 100644
--- a/src/FSharp.Core/tasks.fsi
+++ b/src/FSharp.Core/tasks.fsi
@@ -457,3 +457,288 @@ module HighPriority =
         /// </summary>
         member inline MergeSources< ^TResult1, ^TResult2> :
             task1: Task< ^TResult1 > * task2: Task< ^TResult2 > -> Task<struct (^TResult1 * ^TResult2)>
+
+namespace Microsoft.FSharp.Control
+
+open System.Threading.Tasks
+open Microsoft.FSharp.Core
+
+/// <summary>Contains camelCase module-level functions for <see cref="T:System.Threading.Tasks.Task`1"/> computations.</summary>
+///
+/// <category index="1">Async Programming</category>
+[<RequireQualifiedAccess>]
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module Task =
+
+    /// <summary>Creates a task that returns the given value.</summary>
+    ///
+    /// <param name="value">The value to return.</param>
+    ///
+    /// <returns>A completed task that returns <c>value</c>.</returns>
+    ///
+    /// <example id="task-result-1">
+    /// <code lang="fsharp">
+    /// let t = Task.result 42
+    /// t.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Result")>]
+    val inline result: value: 'T -> Task<'T>
+
+    /// <summary>Creates a task that applies the mapping function to the result of the given task.</summary>
+    ///
+    /// <param name="mapping">The function to apply to the result.</param>
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A task that applies <c>mapping</c> to the result of <c>task</c>.</returns>
+    ///
+    /// <example id="task-map-1">
+    /// <code lang="fsharp">
+    /// let t = Task.result 21 |> Task.map (fun x -> x * 2)
+    /// t.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Map")>]
+    val inline map: mapping: ('T -> 'U) -> task: Task<'T> -> Task<'U>
+
+    /// <summary>Creates a task that passes the result of the given task to the binder function.</summary>
+    ///
+    /// <param name="binder">A function that takes the result of the task and returns a new task.</param>
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A task that performs a monadic bind on the result of <c>task</c>.</returns>
+    ///
+    /// <example id="task-bind-1">
+    /// <code lang="fsharp">
+    /// let t = Task.result 21 |> Task.bind (fun x -> Task.result (x * 2))
+    /// t.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Bind")>]
+    val inline bind: binder: ('T -> Task<'U>) -> task: Task<'T> -> Task<'U>
+
+    /// <summary>Creates a task that runs the given task and ignores its result.</summary>
+    ///
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A task that is equivalent to the input task, but disregards the result.</returns>
+    ///
+    /// <example id="task-ignore-1">
+    /// <code lang="fsharp">
+    /// let t : Task&lt;unit&gt; = Task.result 42 |> Task.ignore&lt;int&gt;
+    /// t.Result // evaluates to ()
+    /// </code>
+    /// </example>
+    [<CompiledName("Ignore")>]
+    [<RequiresExplicitTypeArguments>]
+    val inline ignore<'T> : task: Task<'T> -> Task<unit>
+
+    /// <summary>Creates a <c>Task</c> that yields the original result on success, or the result of
+    /// <c>handler exn</c> for non-cancellation exceptions.</summary>
+    /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged
+    /// (and the task remains Canceled) in order to maintain cancellation semantics, and therefore are never passed to <c>handler</c>.
+    /// </remarks>
+    /// <param name="handler">A function to handle (non-cancellation) exceptions, yielding a recovery value based on the exception.
+    /// Any exception thrown by <c>handler</c> will propagate.</param>
+    /// <param name="task">The input <c>Task</c>.</param>
+    /// <returns>A <c>Task</c> that yields the result of <c>task</c> on success, or <c>handler exn</c> on failure.
+    /// Propagates the underlying cancellation exception when <c>task</c> is canceled.</returns>
+    /// <example id="task-catchwith-1">
+    /// <code lang="fsharp">
+    /// let safeDiv x y =
+    ///     task { return x / y }
+    ///     |> Task.catchWith (fun _ -> 0)
+    /// (safeDiv 10 0).Result // evaluates to 0
+    /// </code>
+    /// </example>
+    [<CompiledName("CatchWith")>]
+    val inline catchWith: handler: (exn -> 'T) -> task: Task<'T> -> Task<'T>
+
+    /// <summary>Creates a <c>Task</c> that reifies the outcome of the given <c>Task</c> as a <c>Result</c>:
+    /// <c>Ok</c> on success, <c>Error</c> on failure, so faults become values. Cancellation still propagates.</summary>
+    /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged
+    /// (and the task remains Canceled) in order to maintain cancellation semantics.</remarks>
+    /// <param name="task">The input <c>Task</c>.</param>
+    /// <returns>A <c>Task</c> that yields a <c>Result</c>: <c>Ok</c> with the outcome on success,
+    /// or <c>Error</c> with the exception on failure.
+    /// Propagates the underlying cancellation exception when <c>task</c> is canceled.</returns>
+    /// <example id="task-catch-1">
+    /// <code lang="fsharp">
+    /// let safeDiv x y = task { return x / y } |> Task.catch
+    /// (safeDiv 10 2).Result // evaluates to Ok 5
+    /// (safeDiv 10 0).Result // evaluates to Error (DivideByZeroException ...)
+    /// </code>
+    /// </example>
+    [<CompiledName("Catch")>]
+    val catch: task: Task<'T> -> Task<Result<'T, exn>>
+
+    /// <summary>A completed task that returns <c>unit</c>. This is a <c>Task&lt;unit&gt;</c> (not the non-generic <c>Task.CompletedTask</c>).</summary>
+    ///
+    /// <example id="task-empty-1">
+    /// <code lang="fsharp">
+    /// Task.empty.Result // evaluates to ()
+    /// </code>
+    /// </example>
+    [<CompiledName("Empty")>]
+    val empty: Task<unit>
+
+#if NETSTANDARD2_1
+    /// <summary>Converts a <see cref="T:System.Threading.Tasks.ValueTask`1"/> to a <see cref="T:System.Threading.Tasks.Task`1"/>.</summary>
+    ///
+    /// <param name="valueTask">The input value task.</param>
+    ///
+    /// <returns>A task equivalent to the given value task.</returns>
+    ///
+    /// <example id="task-ofvaluetask-1">
+    /// <code lang="fsharp">
+    /// let vt = ValueTask&lt;int&gt;(42)
+    /// let t = Task.ofValueTask vt
+    /// t.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("OfValueTask")>]
+    val inline ofValueTask: valueTask: ValueTask<'T> -> Task<'T>
+#endif
+
+#if NETSTANDARD2_1
+/// <summary>Contains camelCase module-level functions for <see cref="T:System.Threading.Tasks.ValueTask`1"/> computations.</summary>
+///
+/// <category index="1">Async Programming</category>
+[<RequireQualifiedAccess>]
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module ValueTask =
+
+    /// <summary>Creates a value task that returns the given value.</summary>
+    ///
+    /// <param name="value">The value to return.</param>
+    ///
+    /// <returns>A completed value task that returns <c>value</c>.</returns>
+    ///
+    /// <example id="valuetask-result-1">
+    /// <code lang="fsharp">
+    /// let vt = ValueTask.result 42
+    /// vt.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Result")>]
+    val inline result: value: 'T -> ValueTask<'T>
+
+    /// <summary>Creates a value task that applies the mapping function to the result of the given value task.</summary>
+    ///
+    /// <param name="mapping">The function to apply to the result.</param>
+    /// <param name="task">The input value task.</param>
+    ///
+    /// <returns>A value task that applies <c>mapping</c> to the result of <c>task</c>.</returns>
+    ///
+    /// <example id="valuetask-map-1">
+    /// <code lang="fsharp">
+    /// let vt = ValueTask.result 21 |> ValueTask.map (fun x -> x * 2)
+    /// vt.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Map")>]
+    val inline map: mapping: ('T -> 'U) -> task: ValueTask<'T> -> ValueTask<'U>
+
+    /// <summary>Creates a value task that passes the result of the given value task to the binder function.</summary>
+    ///
+    /// <param name="binder">A function that takes the result of the value task and returns a new value task.</param>
+    /// <param name="task">The input value task.</param>
+    ///
+    /// <returns>A value task that performs a monadic bind on the result of <c>task</c>.</returns>
+    ///
+    /// <example id="valuetask-bind-1">
+    /// <code lang="fsharp">
+    /// let vt = ValueTask.result 21 |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+    /// vt.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("Bind")>]
+    val inline bind: binder: ('T -> ValueTask<'U>) -> task: ValueTask<'T> -> ValueTask<'U>
+
+    /// <summary>Creates a value task that runs the given value task and ignores its result.</summary>
+    ///
+    /// <remarks>When the value task is already synchronously complete, this avoids allocating a <c>Task</c>.</remarks>
+    ///
+    /// <param name="task">The input value task.</param>
+    ///
+    /// <returns>A value task that is equivalent to the input value task, but disregards the result.</returns>
+    ///
+    /// <example id="valuetask-ignore-1">
+    /// <code lang="fsharp">
+    /// let vt : ValueTask&lt;unit&gt; = ValueTask.result 42 |> ValueTask.ignore&lt;int&gt;
+    /// vt.Result // evaluates to ()
+    /// </code>
+    /// </example>
+    [<CompiledName("Ignore")>]
+    [<RequiresExplicitTypeArguments>]
+    val inline ignore<'T> : task: ValueTask<'T> -> ValueTask<unit>
+
+    /// <summary>Creates a <c>ValueTask</c> that yields the original result on success, or the result of
+    /// <c>handler exn</c> for non-cancellation exceptions.</summary>
+    /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged
+    /// (and the task remains Canceled) in order to maintain cancellation semantics,
+    /// and therefore are never passed to <c>handler</c>.
+    /// </remarks>
+    /// <param name="handler">A function to handle (non-cancellation) exceptions, yielding a recovery value based on the exception.
+    /// Any exception thrown by <c>handler</c> will propagate.</param>
+    /// <param name="task">The input <c>ValueTask</c>.</param>
+    /// <returns>A <c>ValueTask</c> that yields the result of <c>task</c> on success,
+    /// or <c>handler exn</c> on failure.
+    /// Propagates the underlying cancellation exception when <c>task</c> is canceled.</returns>
+    ///
+    /// <example id="valuetask-catchwith-1">
+    /// <code lang="fsharp">
+    /// let safeDiv x y =
+    ///     task { return x / y }
+    ///     |> ValueTask.ofTask
+    ///     |> ValueTask.catchWith (fun _ -> 0)
+    /// (safeDiv 10 0).Result // evaluates to 0
+    /// </code>
+    /// </example>
+    [<CompiledName("CatchWith")>]
+    val inline catchWith: handler: (exn -> 'T) -> task: ValueTask<'T> -> ValueTask<'T>
+
+    /// <summary>Creates a <c>ValueTask</c> that reifies the outcome of the given <c>ValueTask</c> as a <c>Result</c>:
+    /// <c>Ok</c> on success, <c>Error</c> on failure, so faults become values. Cancellation still propagates.</summary>
+    /// <remarks><c>OperationCanceledException</c> and derived types such as <c>TaskCanceledException</c> propagate unchanged
+    /// (and the task remains Canceled) in order to maintain cancellation semantics.</remarks>
+    /// <param name="task">The input <c>ValueTask</c>.</param>
+    /// <returns>A <c>ValueTask</c> that yields a <c>Result</c>: <c>Ok</c> with the outcome on success,
+    /// or <c>Error</c> with the exception on failure.
+    /// Propagates the underlying cancellation exception when <c>task</c> is canceled.</returns>
+    /// <example id="valuetask-catch-1">
+    /// <code lang="fsharp">
+    /// let safeDiv x y = task { return x / y } |> ValueTask.ofTask |> ValueTask.catch
+    /// (safeDiv 10 2).Result // evaluates to Ok 5
+    /// (safeDiv 10 0).Result // evaluates to Error (DivideByZeroException ...)
+    /// </code>
+    /// </example>
+    [<CompiledName("Catch")>]
+    val catch: task: ValueTask<'T> -> ValueTask<Result<'T, exn>>
+
+    /// <summary>A completed value task that returns <c>unit</c>.</summary>
+    ///
+    /// <example id="valuetask-empty-1">
+    /// <code lang="fsharp">
+    /// ValueTask.empty.Result // evaluates to ()
+    /// </code>
+    /// </example>
+    [<CompiledName("Empty")>]
+    val empty: ValueTask<unit>
+
+    /// <summary>Converts a <see cref="T:System.Threading.Tasks.Task`1"/> to a <see cref="T:System.Threading.Tasks.ValueTask`1"/>.</summary>
+    ///
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A value task equivalent to the given task.</returns>
+    ///
+    /// <example id="valuetask-oftask-1">
+    /// <code lang="fsharp">
+    /// let t = Task.FromResult 42
+    /// let vt = ValueTask.ofTask t
+    /// vt.Result // evaluates to 42
+    /// </code>
+    /// </example>
+    [<CompiledName("OfTask")>]
+    val inline ofTask: task: Task<'T> -> ValueTask<'T>
+#endif
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
index 89fb1bb6146..175102ee368 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.debug.bsl
@@ -603,8 +603,8 @@ Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
@@ -617,6 +617,14 @@ Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncRet
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T)
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
@@ -801,6 +809,14 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundT
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
@@ -2668,4 +2684,4 @@ Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
index 6d29205d290..cdf68c2d1ef 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
@@ -603,8 +603,8 @@ Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
@@ -617,6 +617,14 @@ Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncRet
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T)
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
@@ -800,6 +808,14 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundT
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
@@ -2667,4 +2683,4 @@ Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString()
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name()
 Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType
-Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
\ No newline at end of file
+Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType()
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
index d8d7ff44b21..cac5fe9d0ef 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.debug.bsl
@@ -605,8 +605,8 @@ Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]])
 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
-Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState)
@@ -619,6 +619,14 @@ Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncRet
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T)
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
@@ -673,8 +681,8 @@ Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_Def
 Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
 Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
@@ -803,8 +811,26 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundT
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.ValueTask`1[TResult]], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] Result[T](T)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
index db9f41d97a8..537095d9e10 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl
@@ -619,6 +619,14 @@ Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncRet
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T)
 Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T])
+Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T)
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
 Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
@@ -673,8 +681,8 @@ Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_Def
 Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]])
-Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
+Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken()
 Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
 Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken])
@@ -803,8 +811,26 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundT
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task()
 Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder
 Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.ValueTask`1[TResult]], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] Result[T](T)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri)
 Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest)
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
index 1694e8eb4ca..faf41f04322 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
@@ -83,6 +83,8 @@
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\NestedTaskFailures.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\MailboxProcessorType.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\AsyncModule.fs" />
+    <Compile Include="FSharp.Core\Microsoft.FSharp.Control\AsyncModuleFunctions.fs" />
+    <Compile Include="FSharp.Core\Microsoft.FSharp.Control\TaskModuleFunctions.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\ObservableModule.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Control\EventModule.fs" />
     <Compile Include="FSharp.Core\Microsoft.FSharp.Reflection\FSharpReflection.fs" />
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModuleFunctions.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModuleFunctions.fs
new file mode 100644
index 00000000000..3335e6910ac
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModuleFunctions.fs
@@ -0,0 +1,262 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+// Tests for camelCase functions in module Async
+module FSharp.Core.UnitTests.Controa.AsyncModuleFunctionsTestsl
+
+open System
+open System.Threading
+open System.Threading.Tasks
+open Xunit
+
+#if NETFRAMEWORK // Polyfill for netstandard2.0 
+let cancelWithToken (tcs: TaskCompletionSource<'T>) =
+    tcs.SetCanceled() // No CT overload available
+    CancellationToken.None // so exception won't reference one
+#else    
+let cancelWithToken (tcs: TaskCompletionSource<'T>) =
+    let ct = CancellationToken true
+    tcs.SetCanceled ct
+    ct
+#endif
+
+let asyncWait (a: Async<'T>): 'T = Async.RunSynchronouslyImmediate a
+let asyncWaitWithCt (ct: CancellationToken) (a: Async<'T>): 'T = Async.RunSynchronously(a, cancellationToken = ct)
+
+[<Fact>]
+let ``Async.result wraps value`` () =
+    let actual = Async.result 42 |> asyncWait
+    Assert.Equal(42, actual)
+
+
+[<Fact>]
+let ``Async.map transforms value`` () =
+    let actual = Async.result 21 |> Async.map (fun x -> x * 2) |> asyncWait
+    Assert.Equal(42, actual)
+
+[<Fact>]
+let ``Async.map propagates incoming exception`` () =
+    let a = async { return failwith "boom" : int } |> Async.map (fun x -> x * 2)
+    let e = Assert.Throws<exn>(fun () -> a |> asyncWait |> ignore)
+    Assert.Equal("boom", e.Message)
+
+[<Fact>]
+let ``Async.map propagates mapper exception as Fault`` () =
+    let a = Async.result () |> Async.map (fun () -> failwith "boom")
+    let e = Assert.Throws<exn>(fun () -> a |> asyncWait |> ignore)
+    Assert.Equal("boom", e.Message)
+
+[<Fact>]
+let ``Async.map propagates Cancellation (sync)`` () =
+    let ct = CancellationToken true
+    let a = Async.result 2 |> Async.map (fun x -> x * 2)
+    let e = Assert.Throws<OperationCanceledException>(fun () -> a |> asyncWaitWithCt ct |> ignore)
+    Assert.Equal(ct, e.CancellationToken)
+
+[<Fact>]
+let ``Async.map propagates Cancellation (async)`` () =
+    let mutable mapperWasCalled = false
+    let cts = new CancellationTokenSource()
+    let a =
+        async { do! Async.Sleep 5000 }
+        |> Async.map (fun () -> async { mapperWasCalled <- true })
+    let t = Async.StartAsTask(a, cancellationToken = cts.Token)
+    cts.Cancel()
+    let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+    Assert.NotEqual(cts.Token, e.CancellationToken)
+    Assert.False mapperWasCalled
+
+
+[<Fact>]
+let ``Async.bind threads value`` () =
+    let actual =
+        Async.result 21
+        |> Async.bind (fun x -> Async.result (x * 2))
+        |> asyncWait
+    Assert.Equal(42, actual)
+
+[<Fact>]
+let ``Async.bind propagates incoming exception (sync)`` () =
+    let a = async { return failwith "boom" } |> Async.bind Async.result
+    let e = Assert.Throws<exn>(fun () -> a |> asyncWait |> ignore)
+    Assert.Equal("boom", e.Message)
+    
+[<Fact>]
+let ``Async.bind propagates binder exception as Fault (async)`` () =
+    let a = Async.result 5 |> Async.bind (fun x -> async { failwith $"boom {x}"})
+    let e = Assert.Throws<exn>(fun () -> asyncWait a)
+    Assert.Equal("boom 5", e.Message)
+        
+[<Fact>]
+let ``Async.bind propagates Cancellation (sync)`` () =
+    let ct = CancellationToken true
+    let a = Async.result 2 |> Async.bind Async.result
+    let e = Assert.Throws<OperationCanceledException>(fun () -> a |> asyncWaitWithCt ct |> ignore)
+    Assert.Equal(ct, e.CancellationToken)
+
+[<Fact>]
+let ``Async.bind propagates Cancellation (async)`` () =
+    let cts = new CancellationTokenSource()
+    let mutable binderWasCalled = false
+    let a =
+        async { do! Async.Sleep 5000 }
+        |> Async.bind (fun () -> async { binderWasCalled <- true })
+    let t = Async.StartAsTask(a, cancellationToken = cts.Token)
+    cts.Cancel()
+    let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+    Assert.NotEqual(cts.Token, e.CancellationToken)
+    Assert.False binderWasCalled
+
+
+[<Fact>]
+let ``Async.ignore discards result (sync)`` () =
+    let actual = Async.result 42 |> Async.ignore<int> |> asyncWait
+    Assert.Equal((), actual)
+
+[<Fact>]
+let ``Async.ignore discards result (async)`` () =
+    let tcs = TaskCompletionSource<int>()
+    let t = async { return! tcs.Task |> Async.AwaitTask } |> Async.ignore<int> |> Async.StartAsTask
+    tcs.SetResult 42
+    Assert.Equal((), t.Result)
+    
+[<Fact>]
+let ``Async.ignore propagates incoming exception (sync)`` () =
+    let a = async { return failwith "boom" : int } |> Async.ignore<int>
+    let e = Assert.Throws<exn>(fun () -> a |> asyncWait)
+    Assert.Equal("boom", e.Message)
+
+[<Fact>]
+let ``Async.ignore propagates incoming exception (async)`` () =
+    let tcs = TaskCompletionSource<int>()
+    let t = async { return! tcs.Task |> Async.AwaitTask } |> Async.ignore<int> |> Async.StartAsTask
+    tcs.SetException(Exception "boom")
+    let e = Assert.ThrowsAsync<AggregateException>(fun () -> t).Result.InnerException
+    Assert.Equal("boom", e.Message)
+
+[<Fact>]
+let ``Async.ignore propagates Cancellation (sync)`` () =
+    let ct = CancellationToken true
+    let a = Async.result 2 |> Async.ignore<int>
+    let e = Assert.Throws<OperationCanceledException>(fun () -> a |> asyncWaitWithCt ct)
+    Assert.Equal(ct, e.CancellationToken)
+
+[<Fact>]
+let ``Async.ignore propagates Cancellation (async)`` () =
+    let mutable cancellationFailed = false
+    let cts = new CancellationTokenSource()
+    let a =
+        async { do! Async.Sleep 5000
+                cancellationFailed <- true
+                return 42 }
+        |> Async.ignore<int>
+    let t = Async.StartAsTask(a, cancellationToken = cts.Token)
+    cts.Cancel()
+    let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+    Assert.NotEqual(cts.Token, e.CancellationToken)
+    Assert.False cancellationFailed
+
+
+[<Fact>]
+let ``Async.catchWith passes through success (sync)`` () =
+    let source = Async.result 42
+    let a = source |> Async.catchWith (fun _ -> -1)
+    Assert.Equal(42, asyncWait a)
+
+[<Fact>]
+let ``Async.catchWith passes through success (async)`` () = async {
+    let tcs = TaskCompletionSource<int>()
+    let! a = async { return! tcs.Task |> Async.AwaitTask } |> Async.catchWith (fun _ -> -1) |> Async.StartChild
+    tcs.SetResult 42
+    let! res = a
+    Assert.Equal(42, res) }
+
+[<Fact>]
+let ``Async.catchWith recovers from exception (sync)`` () = async {
+    let! actual =
+        async { return failwith "boom" : int }
+        |> Async.catchWith (fun e -> Assert.Equal("boom", e.Message); -1)
+    Assert.Equal(-1, actual) }
+
+[<Fact>]
+let ``Async.catchWith recovers from exception (async)`` () = async {
+    let tcs = TaskCompletionSource<int>()
+    let! a = async { return! tcs.Task |> Async.AwaitTask } |> Async.catchWith (fun _ -> -1) |> Async.StartChild
+    tcs.SetException(Exception "boom")
+    let! result = a
+    Assert.Equal(-1, result) }
+
+[<Fact>]
+let ``Async.catchWith propagates Cancellation (sync)`` () =
+    let mutable cancellationFailed = false
+    let ct = CancellationToken true
+    let a = async { do! Async.Sleep 5000
+                    cancellationFailed <- true
+                    return 42 }
+            |> Async.catchWith (fun _ -> -1)
+    let e = Assert.Throws<OperationCanceledException>(fun () -> a |> asyncWaitWithCt ct |> ignore)
+    Assert.Equal(ct, e.CancellationToken)
+    Assert.False cancellationFailed
+
+[<Fact>]
+let ``Async.catchWith propagates Cancellation (async)`` () =
+    let mutable cancellationFailed = false
+    let cts = new CancellationTokenSource()
+    let a =
+        async { do! Async.Sleep 5000
+                cancellationFailed <- true
+                return 42 }
+        |> Async.catchWith (fun _ -> -1)
+    let t = Async.StartAsTask(a, cancellationToken = cts.Token)
+    cts.Cancel()
+    let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+    Assert.NotEqual(cts.Token, e.CancellationToken)
+
+
+[<Fact>]
+let ``Async.catch returns Ok on success (sync)`` () =
+    let actual = Async.result 42 |> Async.catch |> asyncWait
+    Assert.Equal(Ok 42, actual)
+
+[<Fact>]
+let ``Async.catch returns Ok on success (async)`` () : unit =
+    let tcs = TaskCompletionSource<int>()
+    let t = async { return! tcs.Task |> Async.AwaitTask } |> Async.catch |> Async.StartAsTask
+    tcs.SetResult 42
+    Assert.Equal(Ok 42, t.Result)
+
+[<Fact>]
+let ``Async.catch returns Error on exception`` () =
+    let a = async { return failwith "boom" : int } |> Async.catch
+    match a |> asyncWait with
+    | Error ex -> Assert.Equal("boom", ex.Message)
+    | Ok _ -> failwith "unexpected success"
+
+[<Fact>]
+let ``Async.catch returns Error on exception (async)`` () : unit =
+    let a = async { do! Async.Sleep 1
+                    return failwith "boom" } |> Async.catch
+    match a |> asyncWait with
+    | Error ex -> Assert.Equal("boom", ex.Message)
+    | Ok _ -> failwith "unexpected success"
+
+[<Fact>]
+let ``Async.catch propagates Cancellation (sync)`` () =
+    let ct = CancellationToken true
+    let a = async { do! Async.Sleep 5000 } |> Async.catch
+    let e = Assert.Throws<OperationCanceledException>(fun () -> a |> asyncWaitWithCt ct |> ignore)
+    Assert.Equal(ct, e.CancellationToken)
+
+[<Fact>]
+let ``Async.catch propagates Cancellation (async)`` () =
+    let cts = new CancellationTokenSource()
+    let a = async { do! Async.Sleep 5000 } |> Async.catch
+    let t = Async.StartAsTask(a, cancellationToken = cts.Token)
+    cts.Cancel()
+    let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+    Assert.NotEqual(cts.Token, e.CancellationToken)
+
+
+[<Fact>]
+let ``Async.empty returns unit`` () =
+    let actual = Async.empty |> asyncWait
+    Assert.Equal((), actual)
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
new file mode 100644
index 00000000000..b3b40724a81
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
@@ -0,0 +1,620 @@
+
+// Tests for camelCase functions in module Task and module ValueTask
+
+namespace FSharp.Core.UnitTests.Control
+
+open System
+open System.Threading
+open System.Threading.Tasks
+open Xunit
+
+module TaskModuleFunctionsTests =
+
+#if NETFRAMEWORK // Polyfill for netstandard2.0 
+    type Task<'T> with member x.IsCompletedSuccessfully = x.Status = TaskStatus.RanToCompletion
+    let cancelWithToken (tcs: TaskCompletionSource<'T>) =
+        tcs.SetCanceled() // No CT overload available
+        CancellationToken.None // so exception won't reference one
+#else    
+    let cancelWithToken (tcs: TaskCompletionSource<'T>) =
+        let ct = CancellationToken true
+        tcs.SetCanceled ct
+        ct
+#endif
+
+    [<Fact>]
+    let ``Task.result wraps value`` () =
+        let t = Task.result 42
+        Assert.Equal(42, t.Result)
+        
+
+    [<Fact>]
+    let ``Task.map transforms value (sync)`` () =
+        let t = Task.result 21 |> Task.map (fun x -> x * 2)
+        Assert.True t.IsCompleted
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.map transforms value (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.map (fun x -> x * 2)
+        Assert.False t.IsCompleted
+        tcs.SetResult 21
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.map propagates incoming exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> Task.map (fun x -> x * 2)
+        let! e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.map propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.map (fun x -> x * 2)
+        tcs.SetException(Exception "boom")
+        let! e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+            
+    [<Fact>]
+    let ``Task.map propagates mapper exception as Fault (sync)`` () =
+        let t = Task.result () |> Task.map (fun () -> failwith "boom")
+        let! e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.map propagates mapper exception as Fault (async)`` () =
+        let tcs = TaskCompletionSource<unit>()
+        let t = tcs.Task |> Task.map (fun () -> failwith "boom")
+        tcs.SetResult ()
+        let! e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.map propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> Task.map (fun x -> x * 2)
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``Task.map propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.map (fun x -> x * 2)
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+
+    [<Fact>]
+    let ``Task.bind threads value (sync)`` () =
+        let t = Task.result 21 |> Task.bind (fun x -> Task.result (x * 2))
+        Assert.True t.IsCompleted
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.bind threads value (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.bind (fun x -> Task.result (x * 2))
+        Assert.False t.IsCompleted
+        tcs.SetResult 21
+        Assert.Equal(42, t.Result)
+    
+    [<Fact>]
+    let ``Task.bind propagates incoming exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> Task.bind (fun x -> Task.result (x * 2))
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.bind propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.bind (fun x -> Task.result (x * 2))
+        tcs.SetException(Exception "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+            
+    [<Fact>]
+    let ``Task.bind propagates binder exception as Fault (sync)`` () =
+        let t = Task.result () |> Task.bind (fun () -> failwith "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+        
+    [<Fact>]
+    let ``Task.bind propagates binder exception as Fault (async)`` () =
+        let tcs = TaskCompletionSource<unit>()
+        let t = tcs.Task |> Task.bind (fun () -> failwith "boom")
+        tcs.SetResult ()
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.bind propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> Task.bind (fun x -> Task.result (x * 2))
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``Task.bind propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.bind (fun x -> Task.result (x * 2))
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    
+    [<Fact>]
+    let ``Task.ignore discards result (sync)`` () : unit =
+        let t = Task.result 42 |> Task.ignore<int>
+        Assert.True t.IsCompletedSuccessfully
+        t.Result : unit
+
+    [<Fact>]
+    let ``Task.ignore discards result (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.ignore<int>
+        Assert.False t.IsCompleted
+        tcs.SetResult 42
+        Assert.True t.IsCompletedSuccessfully
+        t.Result : unit
+        
+    [<Fact>]
+    let ``Task.ignore propagates incoming exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> Task.ignore<int>
+        Assert.True t.IsCompleted
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.ignore propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.ignore<int>
+        Assert.False t.IsCompleted
+        tcs.SetException(Exception "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Task.ignore propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> Task.ignore<int>
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``Task.ignore propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.ignore<int>
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    
+    [<Fact>]
+    let ``Task.catchWith recovers from exception (sync)`` () =
+        let source = Task.FromException<int>(Exception "boom")
+        let t = source |> Task.catchWith (fun _ -> -1)
+        Assert.Equal(-1, t.Result)
+
+    [<Fact>]
+    let ``Task.catchWith recovers from exception (async)`` () : Task =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.catchWith (fun _ -> -1)
+        tcs.SetException(Exception "boom")
+        task {
+            let! result = t
+            Assert.Equal(-1, result)
+        }
+
+    [<Fact>]
+    let ``Task.catchWith passes through success (sync)`` () =
+        let source = Task.result 42
+        let t = source |> Task.catchWith (fun _ -> -1)
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.catchWith passes through success (async)`` () : Task =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.catchWith (fun _ -> -1)
+        Assert.False t.IsCompleted
+        tcs.SetResult 42
+        task {
+            let! result = t
+            Assert.Equal(42, result)
+        }
+
+    [<Fact>]
+    let ``Task.catchWith propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> Task.catchWith (fun _ -> -1)
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``Task.catchWith propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.catchWith (fun _ -> -1)
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    
+    [<Fact>]
+    let ``Task.catch returns Ok on success (sync)`` () : unit=
+        let t = Task.result 42 |> Task.catch
+        Assert.Equal(Ok 42, t.Result)
+
+    [<Fact>]
+    let ``Task.catch returns Ok on success (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = Task.catch tcs.Task
+        tcs.SetResult 42
+        Assert.Equal(Ok 42, t.Result)
+
+    [<Fact>]
+    let ``Task.catch returns Error on exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> Task.catch
+        match t.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "unexpected success"
+
+    [<Fact>]
+    let ``Task.catch returns Error on exception (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.catch
+        tcs.SetException(Exception "boom")
+        match t.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "unexpected success"
+
+    [<Fact>]
+    let ``Task.catch propagates cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> Task.catch
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``Task.catch propagates cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> Task.catch
+        let ct = CancellationToken true
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+
+    [<Fact>]
+    let ``Task.empty returns completed unit task`` () =
+        let t = Task.empty
+        Assert.True t.IsCompletedSuccessfully
+        Assert.Equal((), t.Result)
+
+
+#if NETSTANDARD2_1
+    [<Fact>]
+    let ``Task.ofValueTask converts ValueTask`` () =
+        let vt = ValueTask<int>(42)
+        let t = Task.ofValueTask vt
+        Assert.Equal(42, t.Result)
+
+    let ``Task.ofValueTask converts faulted ValueTask`` () =
+        let vt = ValueTask<int>(Task.FromException<int>(Exception "boom"))
+        let t = Task.ofValueTask vt
+        let e = Assert.ThrowsAsync<Exception>(fun () -> t).Result
+        Assert.Equal("boom", e.Message)
+
+module ValueTaskModuleFunctionsTests =
+
+    let cancelWithToken (tcs: TaskCompletionSource<'T>) =
+        let ct = CancellationToken true
+        tcs.SetCanceled ct
+        ct
+
+    [<Fact>]
+    let ``ValueTask.result wraps value`` () =
+        let vt = ValueTask.result 42
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.map transforms value (sync)`` () =
+        let t = ValueTask.result 21 |> ValueTask.map (fun x -> x * 2)
+        Assert.True t.IsCompleted
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.map transforms value (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.map (fun x -> x * 2)
+        Assert.False t.IsCompleted
+        tcs.SetResult 21
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.map propagates incoming exception (sync)`` () =
+        let t = ValueTask.FromException<int>(Exception "boom") |> ValueTask.map (fun x -> x * 2)
+        task {
+            let! e = Assert.ThrowsAnyAsync<Exception>(fun () -> t.AsTask())
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``ValueTask.map propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.map (fun x -> x * 2)
+        tcs.SetException(Exception "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+            
+    [<Fact>]
+    let ``ValueTask.map propagates mapper exception as Fault (sync)`` () =
+        let t = ValueTask.result () |> ValueTask.map (fun () -> failwith "boom")
+        task {
+            let! e = Assert.ThrowsAnyAsync<Exception>(fun () -> t.AsTask())
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``ValueTask.map propagates mapper exception as Fault (async)`` () =
+        let tcs = TaskCompletionSource<unit>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.map (fun () -> failwith "boom")
+        tcs.SetResult ()
+        let e = Assert.ThrowsAsync<exn>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``ValueTask.map propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> ValueTask.ofTask |> ValueTask.map (fun x -> x * 2)
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.map propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.map (fun x -> x * 2)
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+
+    [<Fact>]
+    let ``ValueTask.bind threads value (sync)`` () =
+        let t = ValueTask.result 21 |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        Assert.True t.IsCompleted
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.bind threads value (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        Assert.False t.IsCompleted
+        tcs.SetResult 21
+        Assert.Equal(42, t.Result)
+    
+    [<Fact>]
+    let ``ValueTask.bind propagates incoming exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> ValueTask.ofTask |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        task {
+            let! e = Assert.ThrowsAnyAsync<Exception>(fun () -> t.AsTask())
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``ValueTask.bind propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        tcs.SetException(Exception "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+            
+    [<Fact>]
+    let ``ValueTask.bind propagates binder exception as Fault (sync)`` () =
+        let t = ValueTask.result () |> ValueTask.bind (fun () -> failwith "boom")
+        let e = Assert.ThrowsAsync<exn>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``ValueTask.bind propagates binder exception as Fault (async)`` () =
+        let tcs = TaskCompletionSource<unit>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.bind (fun () -> failwith "boom")
+        tcs.SetResult ()
+        let e = Assert.ThrowsAsync<exn>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``ValueTask.bind propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> ValueTask.ofTask |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.bind propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    
+    [<Fact>]
+    let ``ValueTask.ignore discards result (sync)`` () : unit =
+        let t = ValueTask.result 42 |> ValueTask.ignore<int>
+        Assert.True t.IsCompletedSuccessfully
+        t.Result : unit
+
+    [<Fact>]
+    let ``ValueTask.ignore discards result (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.ignore<int>
+        Assert.False t.IsCompleted
+        tcs.SetResult 42
+        Assert.True t.IsCompletedSuccessfully
+        t.Result : unit
+        
+    [<Fact>]
+    let ``ValueTask.ignore propagates incoming exception (sync)`` () =
+        let t = Task.FromException<int>(Exception "boom") |> ValueTask.ofTask |> ValueTask.ignore<int>
+        Assert.True t.IsCompleted
+        let e = Assert.ThrowsAsync<Exception>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``ValueTask.ignore propagates incoming exception (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.ignore<int>
+        Assert.False t.IsCompleted
+        tcs.SetException(Exception "boom")
+        let e = Assert.ThrowsAsync<Exception>(fun () -> t.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``ValueTask.ignore propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> ValueTask.ofTask |> ValueTask.ignore<int>
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.ignore propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.ignore<int>
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    
+    [<Fact>]
+    let ``ValueTask.catchWith recovers from exception (sync)`` () =
+        let source = Task.FromException<int>(Exception "boom")
+        let t = source |> ValueTask.ofTask |> ValueTask.catchWith (fun _ -> -1)
+        Assert.Equal(-1, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.catchWith recovers from exception (async)`` () : Task =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catchWith (fun _ -> -1)
+        tcs.SetException(Exception "boom")
+        task {
+            let! result = t
+            Assert.Equal(-1, result)
+        }
+
+    [<Fact>]
+    let ``ValueTask.catchWith passes through success (sync)`` () =
+        let source = ValueTask.result 42
+        let t = source |> ValueTask.catchWith (fun _ -> -1)
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.catchWith passes through success (async)`` () : Task =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catchWith (fun _ -> -1)
+        Assert.False t.IsCompleted
+        tcs.SetResult 42
+        task {
+            let! result = t
+            Assert.Equal(42, result)
+        }
+
+    [<Fact>]
+    let ``ValueTask.catchWith propagates Cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> ValueTask.ofTask |> ValueTask.catchWith (fun _ -> -1)
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.catchWith propagates Cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catchWith (fun _ -> -1)
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.catch returns Ok on success (sync)`` () : unit=
+        let t = ValueTask.result 42 |> ValueTask.catch
+        Assert.Equal(Ok 42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.catch returns Ok on success (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catch
+        tcs.SetResult 42
+        Assert.Equal(Ok 42, t.Result)
+
+    [<Fact>]
+    let ``ValueTask.catch returns Error on exception (sync)`` () =
+        let t = ValueTask.FromException<int>(Exception "boom") |> ValueTask.catch
+        match t.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "unexpected success"
+
+    [<Fact>]
+    let ``ValueTask.catch returns Error on exception (async)`` () : unit =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catch
+        tcs.SetException(Exception "boom")
+        match t.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "unexpected success"
+
+    [<Fact>]
+    let ``ValueTask.catch propagates cancellation (sync)`` () =
+        let ct = CancellationToken true
+        let t = Task.FromCanceled<int>(ct) |> ValueTask.ofTask |> ValueTask.catch
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+    [<Fact>]
+    let ``ValueTask.catch propagates cancellation (async)`` () =
+        let tcs = TaskCompletionSource<int>()
+        let t = tcs.Task |> ValueTask.ofTask |> ValueTask.catch
+        let ct = CancellationToken true
+        let ct = cancelWithToken tcs
+        let e = Assert.ThrowsAsync<TaskCanceledException>(fun () -> t.AsTask()).Result
+        Assert.Equal(ct, e.CancellationToken)
+        Assert.True t.IsCanceled
+
+
+    [<Fact>]
+    let ``ValueTask.empty returns completed unit value task`` () : unit =
+        let vt = ValueTask.empty
+        Assert.True vt.IsCompletedSuccessfully
+        vt.Result
+
+    [<Fact>]
+    let ``ValueTask.ofTask wraps Task`` () =
+        let t = Task.FromResult 42
+        let vt = ValueTask.ofTask t
+        Assert.Equal(42, vt.Result)
+        
+    let ``ValueTask.ofTask converts faulted Task`` () =
+        let t = Task.FromException<int>(Exception "boom")
+        let vt = ValueTask.ofTask t
+        let e = Assert.ThrowsAsync<Exception>(fun () -> vt.AsTask()).Result
+        Assert.Equal("boom", e.Message)
+   
+#endif