From 1f5e33fe64b5c449f6ab810e283aea3da2a5a1a2 Mon Sep 17 00:00:00 2001
From: Ruben Bartelink <ruben@bartelink.com>
Date: Thu, 28 May 2026 11:33:27 +0100
Subject: [PATCH 1/3] feat(Async+Task+ValueTask): consistent helper modules

---
 docs/release-notes/.FSharp.Core/11.0.100.md   |   4 +
 src/FSharp.Core/async.fs                      |  42 +++
 src/FSharp.Core/async.fsi                     | 120 +++++++
 src/FSharp.Core/tasks.fs                      | 156 +++++++++
 src/FSharp.Core/tasks.fsi                     | 274 +++++++++++++++
 ...p.Core.SurfaceArea.netstandard20.debug.bsl |  20 +-
 ...Core.SurfaceArea.netstandard20.release.bsl |  20 +-
 ...p.Core.SurfaceArea.netstandard21.debug.bsl |  28 +-
 ...Core.SurfaceArea.netstandard21.release.bsl |  26 ++
 .../FSharp.Core.UnitTests.fsproj              |   2 +
 .../AsyncModuleFunctions.fs                   |  85 +++++
 .../TaskModuleFunctions.fs                    | 312 ++++++++++++++++++
 12 files changed, 1084 insertions(+), 5 deletions(-)
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModuleFunctions.fs
 create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs

diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md
index 70bbaae06fe..234863df2c7 100644
--- a/docs/release-notes/.FSharp.Core/11.0.100.md
+++ b/docs/release-notes/.FSharp.Core/11.0.100.md
@@ -2,3 +2,7 @@
 
 * Fix `Array.exists2` documentation examples to use equal-length arrays; the previous examples would throw `ArgumentException` at runtime instead of returning the documented `false`/`true` values. ([PR #19672](https://github.com/dotnet/fsharp/pull/19672))
 * Move `Async.StartChild` to the "Starting Async Computations" docs category alongside `Async.StartChildAsTask`. ([Issue #19667](https://github.com/dotnet/fsharp/issues/19667))
+
+### Added
+
+* Added camelCase module-level functions `result`, `map`, `bind`, `ignore`, `catchWith`, `catch`, and `empty` in `module`s `Async`,`Task` and `ValueTask`, plus `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 f18e451f357..6f3f238a5e9 100644
--- a/src/FSharp.Core/async.fs
+++ b/src/FSharp.Core/async.fs
@@ -2355,3 +2355,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 b2fe66ddd13..e9c329931c7 100644
--- a/src/FSharp.Core/async.fsi
+++ b/src/FSharp.Core/async.fsi
@@ -1547,3 +1547,123 @@ 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>
+    [<RequireQualifiedAccess>]
+    [<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.RunSynchronously // 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.RunSynchronously // 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.RunSynchronously // 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 {
+        ///         use file = System.IO.File.OpenRead(filename)
+        ///         do! file.AsyncRead(numBytes) |> Async.ignore&lt;int&gt;
+        ///     }
+        /// </code>
+        /// </example>
+        [<CompiledName("Ignore")>]
+        [<RequiresExplicitTypeArguments>]
+        val inline ignore<'T> : computation: Async<'T> -> Async<unit>
+
+        /// <summary>Creates an asynchronous computation that runs the given computation.
+        /// If it raises an exception, the handler function is called with the exception and its result is returned.</summary>
+        ///
+        /// <param name="handler">A function to handle exceptions, returning a recovery value.</param>
+        /// <param name="computation">The input computation.</param>
+        ///
+        /// <returns>An asynchronous computation that returns the result of <c>computation</c>, or the result of <c>handler</c> if an exception is raised.</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.RunSynchronously // evaluates to 0
+        /// </code>
+        /// </example>
+        [<CompiledName("CatchWith")>]
+        val catchWith: handler: (exn -> 'T) -> computation: Async<'T> -> Async<'T>
+
+        /// <summary>Creates an asynchronous computation that runs the given computation and returns its result as <c>Ok</c>,
+        /// or returns <c>Error</c> with the exception if one is raised.</summary>
+        ///
+        /// <param name="computation">The input computation.</param>
+        ///
+        /// <returns>An asynchronous computation that returns <c>Ok</c> of the result or <c>Error</c> of the exception.</returns>
+        ///
+        /// <example id="async-catch-1">
+        /// <code lang="fsharp">
+        /// let safeDiv x y =
+        ///     async { return x / y } |> Async.catch
+        /// safeDiv 10 2 |> Async.RunSynchronously // evaluates to Ok 5
+        /// safeDiv 10 0 |> Async.RunSynchronously // 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.RunSynchronously // 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..9c3c2b29390 100644
--- a/src/FSharp.Core/tasks.fs
+++ b/src/FSharp.Core/tasks.fs
@@ -716,3 +716,159 @@ 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>]
+module Task =
+
+    [<CompiledName("Result")>]
+    let inline result (value: 'T) : Task<'T> =
+        Task.FromResult value
+
+    [<CompiledName("Empty")>]
+    let empty: Task<unit> = result ()
+
+    [<CompiledName("Map")>]
+    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (task: Task<'T>) : Task<'U> =
+        if task.Status = TaskStatus.RanToCompletion then
+            result (mapping task.Result)
+        else
+            TaskBuilder.task {
+                let! v = task
+                return mapping v
+            }
+
+    [<CompiledName("Bind")>]
+    let inline bind ([<InlineIfLambda>] binder: 'T -> Task<'U>) (task: Task<'T>) : Task<'U> =
+        if task.Status = TaskStatus.RanToCompletion then
+            binder task.Result
+        else
+            TaskBuilder.task {
+                let! v = task
+                return! binder 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 e ->
+                    return handler e
+            }
+
+    [<CompiledName("Catch")>]
+    let inline catch (task: Task<'T>) : Task<Result<'T, exn>> =
+        if task.Status = TaskStatus.RanToCompletion then
+            result (Ok task.Result)
+        else
+            TaskBuilder.task {
+                try
+                    let! v = task
+                    return Ok v
+                with e ->
+                    return Error e
+            }
+
+#if NETSTANDARD2_1
+    [<CompiledName("OfValueTask")>]
+    let inline ofValueTask (valueTask: ValueTask<'T>) : Task<'T> =
+        valueTask.AsTask()
+#endif
+
+#if NETSTANDARD2_1
+[<RequireQualifiedAccess>]
+module ValueTask =
+
+    [<CompiledName("Result")>]
+    let inline result (value: 'T) : ValueTask<'T> =
+        ValueTask<'T>(value)
+
+    [<CompiledName("Map")>]
+    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (task: ValueTask<'T>) : ValueTask<'U> =
+        if task.IsCompletedSuccessfully then
+            ValueTask<'U>(mapping task.Result)
+        else
+            let t: Task<'U> =
+                TaskBuilder.task {
+                    let! v = task
+                    return mapping v
+                }
+
+            ValueTask<'U>(t)
+
+    [<CompiledName("Bind")>]
+    let inline bind ([<InlineIfLambda>] binder: 'T -> ValueTask<'U>) (task: ValueTask<'T>) : ValueTask<'U> =
+        if task.IsCompletedSuccessfully then
+            binder task.Result
+        else
+            let t: Task<'U> =
+                TaskBuilder.task {
+                    let! v = task
+                    return! binder 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 e ->
+                        return handler e
+                }
+
+            ValueTask<'T>(t)
+
+    [<CompiledName("Catch")>]
+    let inline catch (task: ValueTask<'T>) : ValueTask<Result<'T, exn>> =
+        if task.IsCompletedSuccessfully then
+            ValueTask<Result<'T, exn>>(Ok task.Result)
+        else
+            let t: Task<Result<'T, exn>> =
+                TaskBuilder.task {
+                    try
+                        let! v = task
+                        return Ok v
+                    with e ->
+                        return Error e
+                }
+
+            ValueTask<Result<'T, exn>>(t)
+
+    [<CompiledName("Empty")>]
+    let empty: ValueTask<unit> = Unchecked.defaultof<_>
+
+    [<CompiledName("OfTask")>]
+    let inline ofTask (task: Task<'T>) : ValueTask<'T> =
+        ValueTask<'T>(task)
+#endif
diff --git a/src/FSharp.Core/tasks.fsi b/src/FSharp.Core/tasks.fsi
index 76d84bcfd28..70209087369 100644
--- a/src/FSharp.Core/tasks.fsi
+++ b/src/FSharp.Core/tasks.fsi
@@ -457,3 +457,277 @@ 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>]
+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 task that runs the given task.
+    /// If it raises an exception, the handler function is called with the exception and its result is returned.</summary>
+    ///
+    /// <param name="handler">A function to handle exceptions, returning a recovery value.</param>
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A task that returns the result of <c>task</c>, or the result of <c>handler</c> if an exception is raised.</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 task that runs the given task and returns its result as <c>Ok</c>,
+    /// or returns <c>Error</c> with the exception if one is raised.</summary>
+    ///
+    /// <param name="task">The input task.</param>
+    ///
+    /// <returns>A task that returns <c>Ok</c> of the result or <c>Error</c> of the exception.</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 inline 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>]
+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 value task that runs the given value task.
+    /// If it raises an exception, the handler function is called with the exception and its result is returned.</summary>
+    ///
+    /// <param name="handler">A function to handle exceptions, returning a recovery value.</param>
+    /// <param name="task">The input value task.</param>
+    ///
+    /// <returns>A value task that returns the result of <c>task</c>, or the result of <c>handler</c> if an exception is raised.</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 value task that runs the given value task and returns its result as <c>Ok</c>,
+    /// or returns <c>Error</c> with the exception if one is raised.</summary>
+    ///
+    /// <param name="task">The input value task.</param>
+    ///
+    /// <returns>A value task that returns <c>Ok</c> of the result or <c>Error</c> of the exception.</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 inline 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 5b6cc0bce4e..33bf7166dac 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])
@@ -745,6 +753,14 @@ Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](Syst
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.Task: 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.Task: 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.Task: 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.Task: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
@@ -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.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl
index 217d4b7c837..401ca3f2d59 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])
@@ -745,6 +753,14 @@ Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](Syst
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.Task: 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.Task: 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.Task: 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.Task: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
@@ -2666,4 +2682,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 43defdb622e..ab4e8539148 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])
@@ -747,6 +755,15 @@ Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](Syst
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.Task: 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.Task: 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.Task: 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.Task: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
@@ -804,6 +821,15 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder
 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.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.ValueTask: 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.ValueTask: 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.ValueTask: 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.ValueTask: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.ValueTask: 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 ed913ea04d3..1a01d717998 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])
@@ -747,6 +755,15 @@ Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](Syst
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T])
 Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.Task: 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.Task: 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.Task: 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.Task: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.Task: System.Threading.Tasks.Task`1[T] Result[T](T)
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T])
 Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]])
@@ -804,6 +821,15 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder
 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.TaskStateMachineData`1[T]: T Result
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T])
+Microsoft.FSharp.Control.ValueTask: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty()
+Microsoft.FSharp.Control.ValueTask: 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.ValueTask: 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.ValueTask: 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.ValueTask: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T])
+Microsoft.FSharp.Control.ValueTask: 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 d4ff59d3cbd..82428892a87 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..3166c72ac00
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/AsyncModuleFunctions.fs
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+// Tests for camelCase functions in module Async
+
+namespace FSharp.Core.UnitTests.Control
+
+open Xunit
+
+module AsyncModuleFunctionsTests =
+
+    [<Fact>]
+    let ``Async.result wraps value`` () =
+        let actual = Async.result 42 |> Async.RunSynchronously
+        Assert.Equal(42, actual)
+
+    [<Fact>]
+    let ``Async.map transforms value`` () =
+        let actual = Async.result 21 |> Async.map (fun x -> x * 2) |> Async.RunSynchronously
+        Assert.Equal(42, actual)
+
+    [<Fact>]
+    let ``Async.map preserves exception`` () =
+        let comp = async { return failwith "boom" : int } |> Async.map (fun x -> x * 2)
+        let e = Assert.Throws<exn>(fun () -> comp |> Async.RunSynchronously |> ignore)
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Async.empty returns unit`` () =
+        let actual = Async.empty |> Async.RunSynchronously
+        Assert.Equal((), actual)
+
+    [<Fact>]
+    let ``Async.bind threads value`` () =
+        let actual =
+            Async.result 21
+            |> Async.bind (fun x -> Async.result (x * 2))
+            |> Async.RunSynchronously
+        Assert.Equal(42, actual)
+
+    [<Fact>]
+    let ``Async.bind preserves exception`` () =
+        let comp = async { return failwith "boom" : int } |> Async.bind Async.result
+        let e = Assert.Throws<exn>(fun () -> comp |> Async.RunSynchronously |> ignore)
+        Assert.Equal("boom", e.Message)
+
+    [<Fact>]
+    let ``Async.ignore discards result`` () =
+        let actual = Async.result 42 |> Async.ignore<int> |> Async.RunSynchronously
+        Assert.Equal((), actual)
+
+    [<Fact>]
+    let ``Async.catchWith recovers from exception`` () =
+        let actual =
+            async { return failwith "boom" : int }
+            |> Async.catchWith (fun e -> Assert.Equal("boom", e.Message); -1)
+            |> Async.RunSynchronously
+        Assert.Equal(-1, actual)
+
+    [<Fact>]
+    let ``Async.catchWith passes through success`` () =
+        let actual =
+            Async.result 42
+            |> Async.catchWith (fun _ -> -1)
+            |> Async.RunSynchronously
+        Assert.Equal(42, actual)
+
+    [<Fact>]
+    let ``Async.catch returns Ok on success`` () =
+        let actual = Async.result 42 |> Async.catch |> Async.RunSynchronously
+        Assert.Equal(Ok 42, actual)
+
+    [<Fact>]
+    let ``Async.catch returns Error on exception`` () =
+        let comp = async { return failwith "boom" : int } |> Async.catch
+        match comp |> Async.RunSynchronously with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "expected Error"
+
+    [<Fact>]
+    let ``Async.ignore runs the computation`` () : System.Threading.Tasks.Task =
+        let comp = async { return failwith "boom" : int } |> Async.ignore<int>
+        task {
+            let! e = Assert.ThrowsAsync<exn>(fun () -> Async.StartAsTask comp)
+            Assert.Equal("boom", e.Message)
+        }
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..6cd1fe48a9c
--- /dev/null
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
@@ -0,0 +1,312 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+// Tests for camelCase functions in module Task and module ValueTask
+
+namespace FSharp.Core.UnitTests.Control
+
+open System
+open System.Threading.Tasks
+open Xunit
+
+module TaskModuleFunctionsTests =
+
+    let pendingTaskSource () = TaskCompletionSource<int>()
+
+    [<Fact>]
+    let ``Task.result wraps value`` () =
+        let t = Task.result 42
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.map transforms value`` () =
+        let t = Task.result 21 |> Task.map (fun x -> x * 2)
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.map propagates exception`` () =
+        let t = Task.FromException<int>(Exception "boom") |> Task.map (fun x -> x * 2)
+        let ex = Assert.Throws<Exception>(fun () -> t.GetAwaiter().GetResult() |> ignore)
+        Assert.Equal("boom", ex.Message)
+
+    [<Fact>]
+    let ``Task.bind threads value`` () =
+        let t = Task.result 21 |> Task.bind (fun x -> Task.result (x * 2))
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.ignore discards result`` () =
+        let t = Task.result 42 |> Task.ignore<int>
+        t.Result
+        Assert.True(t.IsCompletedSuccessfully)
+
+    [<Fact>]
+    let ``Task.catchWith recovers from exception (sync)`` () =
+        let source = Task.FromException<int>(Exception "boom")
+        Assert.True(source.IsCompleted)
+        let t = source |> Task.catchWith (fun _ -> -1)
+        Assert.Equal(-1, t.Result)
+
+    [<Fact>]
+    let ``Task.catchWith recovers from exception (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        let t = tcs.Task |> Task.catchWith (fun _ -> -1)
+        Assert.False(t.IsCompleted)
+        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
+        Assert.True(source.IsCompleted)
+        let t = source |> Task.catchWith (fun _ -> -1)
+        Assert.Equal(42, t.Result)
+
+    [<Fact>]
+    let ``Task.catchWith passes through success (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        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.catch returns Ok on success (sync)`` () =
+        let source = Task.result 42
+        Assert.True(source.IsCompleted)
+        let t = source |> Task.catch
+        Assert.Equal(Ok 42, t.Result)
+
+    [<Fact>]
+    let ``Task.catch returns Ok on success (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        let t = tcs.Task |> Task.catch
+        Assert.False(t.IsCompleted)
+        tcs.SetResult(42)
+        task {
+            let! result = t
+            Assert.Equal(Ok 42, result)
+        }
+
+    [<Fact>]
+    let ``Task.catch returns Error on exception (sync)`` () =
+        let source = Task.FromException<int>(Exception "boom")
+        Assert.True(source.IsCompleted)
+        let t = source |> Task.catch
+        match t.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "expected Error"
+
+    [<Fact>]
+    let ``Task.catch returns Error on exception (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        let t = tcs.Task |> Task.catch
+        Assert.False(t.IsCompleted)
+        tcs.SetException(Exception "boom")
+        task {
+            let! result = t
+            match result with
+            | Error ex -> Assert.Equal("boom", ex.Message)
+            | Ok _ -> failwith "expected Error"
+        }
+
+    [<Fact>]
+    let ``Task.ignore runs the computation`` () : Task =
+        let t = Task.FromException<int>(Exception "boom") |> Task.ignore<int>
+        task {
+            let! e = Assert.ThrowsAsync<exn>(fun () -> t)
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``Task.ignore runs the computation (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        let t = tcs.Task |> Task.ignore<int>
+        Assert.False(t.IsCompleted)
+        tcs.SetException(Exception "boom")
+        task {
+            let! e = Assert.ThrowsAsync<exn>(fun () -> t)
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``Task.empty returns completed unit task`` () =
+        let t = Task.empty
+        t.Result
+        Assert.True(t.IsCompletedSuccessfully)
+
+#if NETSTANDARD2_1
+    [<Fact>]
+    let ``Task.ofValueTask converts value task`` () =
+        let vt = ValueTask<int>(42)
+        let t = Task.ofValueTask vt
+        Assert.Equal(42, t.Result)
+
+module ValueTaskModuleFunctionsTests =
+
+    let pendingTaskSource () = TaskCompletionSource<int>()
+
+    [<Fact>]
+    let ``ValueTask.result wraps value`` () =
+        let vt = ValueTask.result 42
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.map transforms value (sync)`` () =
+        let vt = ValueTask.result 21 |> ValueTask.map (fun x -> x * 2)
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.map transforms value (async)`` () =
+        let vt = ValueTask<int>(Task.FromResult 21) |> ValueTask.map (fun x -> x * 2)
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.bind threads value (sync)`` () =
+        let vt = ValueTask.result 21 |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.bind threads value (async)`` () =
+        let vt = ValueTask<int>(Task.FromResult 21) |> ValueTask.bind (fun x -> ValueTask.result (x * 2))
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.ignore discards result (sync)`` () : unit =
+        let vt = ValueTask.result 42 |> ValueTask.ignore<int>
+        Assert.True(vt.IsCompletedSuccessfully)
+        vt.Result
+
+    [<Fact>]
+    let ``ValueTask.ignore discards result (async)`` () : unit =
+        let vt = ValueTask<int>(Task.FromResult 42) |> ValueTask.ignore<int>
+        vt.Result
+
+    [<Fact>]
+    let ``ValueTask.catchWith recovers from exception (sync)`` () =
+        let source = ValueTask<int>(Task.FromException<int>(Exception "boom"))
+        Assert.True(source.IsCompleted)
+        let vt = source |> ValueTask.catchWith (fun _ -> -1)
+        Assert.Equal(-1, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.catchWith recovers from exception (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catchWith (fun _ -> -1)
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetException(Exception "boom")
+        task {
+            let! result = vt
+            Assert.Equal(-1, result)
+        }
+
+    [<Fact>]
+    let ``ValueTask.catchWith passes through success (sync)`` () =
+        let source = ValueTask.result 42
+        Assert.True(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catchWith (fun _ -> -1)
+        Assert.Equal(42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.catchWith passes through success (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catchWith (fun _ -> -1)
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetResult(42)
+        task {
+            let! result = vt
+            Assert.Equal(42, result)
+        }
+
+    [<Fact>]
+    let ``ValueTask.catch returns Ok on success (sync)`` () =
+        let source = ValueTask.result 42
+        Assert.True(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catch
+        Assert.Equal(Ok 42, vt.Result)
+
+    [<Fact>]
+    let ``ValueTask.catch returns Ok on success (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catch
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetResult(42)
+        task {
+            let! result = vt
+            Assert.Equal(Ok 42, result)
+        }
+
+    [<Fact>]
+    let ``ValueTask.catch returns Error on exception (sync)`` () =
+        let source = ValueTask<int>(Task.FromException<int>(Exception "boom"))
+        Assert.True(source.IsCompleted)
+        let vt = source |> ValueTask.catch
+        match vt.Result with
+        | Error ex -> Assert.Equal("boom", ex.Message)
+        | Ok _ -> failwith "expected Error"
+
+    [<Fact>]
+    let ``ValueTask.catch returns Error on exception (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catch
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetException(Exception "boom")
+        task {
+            let! result = vt
+            match result with
+            | Error ex -> Assert.Equal("boom", ex.Message)
+            | Ok _ -> failwith "expected Error"
+        }
+
+    [<Fact>]
+    let ``ValueTask.ignore runs the computation`` () : Task =
+        let faulted = ValueTask<int>(Task.FromException<int>(Exception "boom"))
+        let vt = faulted |> ValueTask.ignore<int>
+        task {
+            let! e = Assert.ThrowsAsync<exn>(fun () -> vt.AsTask())
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<Fact>]
+    let ``ValueTask.ignore runs the computation (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.ignore<int>
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetException(Exception "boom")
+        task {
+            let! e = Assert.ThrowsAsync<exn>(fun () -> vt.AsTask())
+            Assert.Equal("boom", e.Message)
+        }
+
+    [<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)
+#endif

From d491971da0846c39a34d382304ee3ac32788753b Mon Sep 17 00:00:00 2001
From: Ruben Bartelink <ruben@bartelink.com>
Date: Thu, 28 May 2026 17:26:18 +0100
Subject: [PATCH 2/3] copilot review fixes

---
 docs/release-notes/.FSharp.Core/11.0.100.md   |  2 +-
 src/FSharp.Core/async.fsi                     |  1 -
 src/FSharp.Core/tasks.fs                      |  6 +--
 src/FSharp.Core/tasks.fsi                     |  4 +-
 .../TaskModuleFunctions.fs                    | 46 +++++++++++++++++++
 5 files changed, 52 insertions(+), 7 deletions(-)

diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md
index 234863df2c7..90204288adc 100644
--- a/docs/release-notes/.FSharp.Core/11.0.100.md
+++ b/docs/release-notes/.FSharp.Core/11.0.100.md
@@ -5,4 +5,4 @@
 
 ### Added
 
-* Added camelCase module-level functions `result`, `map`, `bind`, `ignore`, `catchWith`, `catch`, and `empty` in `module`s `Async`,`Task` and `ValueTask`, plus `Task.ofValueTask` and `ValueTask.ofTask`. ([LanguageSuggestion #1466](https://github.com/fsharp/fslang-suggestions/issues/1466), [PR #19844](https://github.com/dotnet/fsharp/pull/19844))
+* Added camelCase module-level functions `result`, `map`, `bind`, `ignore`, `catchWith`, `catch`, and `empty` in `module`s `Async`,`Task`, `ValueTask`, plus `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.fsi b/src/FSharp.Core/async.fsi
index e9c329931c7..60d2f329613 100644
--- a/src/FSharp.Core/async.fsi
+++ b/src/FSharp.Core/async.fsi
@@ -1550,7 +1550,6 @@ namespace Microsoft.FSharp.Control
     /// <summary>Contains camelCase module-level functions for <see cref="T:Microsoft.FSharp.Control.FSharpAsync`1"/> computations.</summary>
     ///
     /// <category index="1">Async Programming</category>
-    [<RequireQualifiedAccess>]
     [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
     module Async =
 
diff --git a/src/FSharp.Core/tasks.fs b/src/FSharp.Core/tasks.fs
index 9c3c2b29390..d102885b0a6 100644
--- a/src/FSharp.Core/tasks.fs
+++ b/src/FSharp.Core/tasks.fs
@@ -777,7 +777,7 @@ module Task =
             }
 
     [<CompiledName("Catch")>]
-    let inline catch (task: Task<'T>) : Task<Result<'T, exn>> =
+    let catch (task: Task<'T>) : Task<Result<'T, exn>> =
         if task.Status = TaskStatus.RanToCompletion then
             result (Ok task.Result)
         else
@@ -850,7 +850,7 @@ module ValueTask =
             ValueTask<'T>(t)
 
     [<CompiledName("Catch")>]
-    let inline catch (task: ValueTask<'T>) : ValueTask<Result<'T, exn>> =
+    let catch (task: ValueTask<'T>) : ValueTask<Result<'T, exn>> =
         if task.IsCompletedSuccessfully then
             ValueTask<Result<'T, exn>>(Ok task.Result)
         else
@@ -866,7 +866,7 @@ module ValueTask =
             ValueTask<Result<'T, exn>>(t)
 
     [<CompiledName("Empty")>]
-    let empty: ValueTask<unit> = Unchecked.defaultof<_>
+    let empty: ValueTask<unit> = result ()
 
     [<CompiledName("OfTask")>]
     let inline ofTask (task: Task<'T>) : ValueTask<'T> =
diff --git a/src/FSharp.Core/tasks.fsi b/src/FSharp.Core/tasks.fsi
index 70209087369..05a502e451e 100644
--- a/src/FSharp.Core/tasks.fsi
+++ b/src/FSharp.Core/tasks.fsi
@@ -566,7 +566,7 @@ module Task =
     /// </code>
     /// </example>
     [<CompiledName("Catch")>]
-    val inline catch: task: Task<'T> -> Task<Result<'T, exn>>
+    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>
     ///
@@ -703,7 +703,7 @@ module ValueTask =
     /// </code>
     /// </example>
     [<CompiledName("Catch")>]
-    val inline catch: task: ValueTask<'T> -> ValueTask<Result<'T, exn>>
+    val catch: task: ValueTask<'T> -> ValueTask<Result<'T, exn>>
 
     /// <summary>A completed value task that returns <c>unit</c>.</summary>
     ///
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
index 6cd1fe48a9c..36b1c8f8fc2 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
@@ -5,6 +5,7 @@
 namespace FSharp.Core.UnitTests.Control
 
 open System
+open System.Threading
 open System.Threading.Tasks
 open Xunit
 
@@ -119,6 +120,28 @@ module TaskModuleFunctionsTests =
             | Ok _ -> failwith "expected Error"
         }
 
+    [<Fact>]
+    let ``Task.catch returns Error on cancellation (sync)`` () =
+        let source = Task.FromCanceled<int>(CancellationToken(true))
+        Assert.True(source.IsCompleted)
+        let t = source |> Task.catch
+        match t.Result with
+        | Error (:? TaskCanceledException) -> ()
+        | r -> failwithf "expected Error(OperationCanceledException) but got %A" r
+
+    [<Fact>]
+    let ``Task.catch returns Error on cancellation (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        Assert.False(tcs.Task.IsCompleted)
+        let t = tcs.Task |> Task.catch
+        Assert.False(t.IsCompleted)
+        tcs.SetCanceled()
+        task {
+            match! t with
+            | Error (:? TaskCanceledException) -> ()
+            | r -> failwithf "expected Error(OperationCanceledException) but got %A" r
+        }
+
     [<Fact>]
     let ``Task.ignore runs the computation`` () : Task =
         let t = Task.FromException<int>(Exception "boom") |> Task.ignore<int>
@@ -276,6 +299,29 @@ module ValueTaskModuleFunctionsTests =
             | Ok _ -> failwith "expected Error"
         }
 
+    [<Fact>]
+    let ``ValueTask.catch returns Error on cancellation (sync)`` () =
+        let source = ValueTask<int>(Task.FromCanceled<int>(CancellationToken(true)))
+        Assert.True(source.IsCompleted)
+        let vt = source |> ValueTask.catch
+        match vt.Result with
+        | Error (:? TaskCanceledException) -> ()
+        | r -> failwithf "expected Error(TaskCanceledException) but got %A" r
+
+    [<Fact>]
+    let ``ValueTask.catch returns Error on cancellation (async)`` () : Task =
+        let tcs = pendingTaskSource()
+        let source = ValueTask<int>(tcs.Task)
+        Assert.False(source.IsCompletedSuccessfully)
+        let vt = source |> ValueTask.catch
+        Assert.False(vt.IsCompletedSuccessfully)
+        tcs.SetCanceled()
+        task {
+            match!  with
+            | Error (:? TaskCanceledException) -> ()
+            | r -> failwithf "expected Error(TaskCanceledException) but got %A" r
+        }
+
     [<Fact>]
     let ``ValueTask.ignore runs the computation`` () : Task =
         let faulted = ValueTask<int>(Task.FromException<int>(Exception "boom"))

From 2f5acf61ebf8151230db4fe8291283118aaf3ab5 Mon Sep 17 00:00:00 2001
From: Ruben Bartelink <ruben@bartelink.com>
Date: Thu, 28 May 2026 18:12:22 +0100
Subject: [PATCH 3/3] Fix netstandard2.0 build

---
 .../Microsoft.FSharp.Control/TaskModuleFunctions.fs  | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

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
index 36b1c8f8fc2..729d464973a 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/TaskModuleFunctions.fs
@@ -38,7 +38,7 @@ module TaskModuleFunctionsTests =
     let ``Task.ignore discards result`` () =
         let t = Task.result 42 |> Task.ignore<int>
         t.Result
-        Assert.True(t.IsCompletedSuccessfully)
+        Assert.True(t.Status = TaskStatus.RanToCompletion) // IsCompletedSuccessfully would work but netstandard2.0
 
     [<Fact>]
     let ``Task.catchWith recovers from exception (sync)`` () =
@@ -114,8 +114,7 @@ module TaskModuleFunctionsTests =
         Assert.False(t.IsCompleted)
         tcs.SetException(Exception "boom")
         task {
-            let! result = t
-            match result with
+            match! t with
             | Error ex -> Assert.Equal("boom", ex.Message)
             | Ok _ -> failwith "expected Error"
         }
@@ -166,7 +165,7 @@ module TaskModuleFunctionsTests =
     let ``Task.empty returns completed unit task`` () =
         let t = Task.empty
         t.Result
-        Assert.True(t.IsCompletedSuccessfully)
+        Assert.True(t.Status = TaskStatus.RanToCompletion) // IsCompletedSuccessfully would work but netstandard2.0
 
 #if NETSTANDARD2_1
     [<Fact>]
@@ -293,8 +292,7 @@ module ValueTaskModuleFunctionsTests =
         Assert.False(vt.IsCompletedSuccessfully)
         tcs.SetException(Exception "boom")
         task {
-            let! result = vt
-            match result with
+            match! vt with
             | Error ex -> Assert.Equal("boom", ex.Message)
             | Ok _ -> failwith "expected Error"
         }
@@ -317,7 +315,7 @@ module ValueTaskModuleFunctionsTests =
         Assert.False(vt.IsCompletedSuccessfully)
         tcs.SetCanceled()
         task {
-            match!  with
+            match! vt with
             | Error (:? TaskCanceledException) -> ()
             | r -> failwithf "expected Error(TaskCanceledException) but got %A" r
         }