Add Source overloads to taskResultOption CE for interop with Result, TaskResult, Option, Task, and Async (#351)

* Initial plan

* Add Source overloads to taskResultOption CE for Result, TaskResult, TaskOption, Task, Async compatibility

Co-authored-by: TheAngryByrd <1490044+TheAngryByrd@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: TheAngryByrd <1490044+TheAngryByrd@users.noreply.github.com>

Author: Copilot

gitbook/taskResultOption/ce.md

@@ -16,3 +16,39 @@ taskResultOption {
   return userTweet post user
 }
 ```
+
+### Example 2
+
+The `taskResultOption` CE supports binding from multiple compatible types, allowing you to mix `TaskResultOption`, `TaskResult`, `Result`, `Option`, `Task`, and `Async` values without manual conversion:
+
+```fsharp
+// parseMode: string -> Result<Mode, string>
+// loadUniverse: Mode -> Task<Result<Universe, string>>
+
+// Task<Result<Report option, string>>
+taskResultOption {
+  // Bind from Result<Mode, string> directly (no manual conversion needed)
+  let! mode = parseMode "fast"
+
+  // Bind from Task<Result<Universe, string>> directly
+  let! universe = loadUniverse mode
+
+  return generateReport universe
+}
+```
+
+### Supported Source Types
+
+The `taskResultOption` CE supports `let!` and `return!` with the following types:
+
+| Type | Behavior |
+|------|----------|
+| `Task<Result<'ok option, 'error>>` | Identity (the CE's native type) |
+| `Task<Result<'ok, 'error>>` | `Ok` value is wrapped in `Some` |
+| `Task<'ok option>` | `Some`/`None` is wrapped in `Ok` |
+| `Task<'ok>` | Value is wrapped in `Some` and then `Ok` |
+| `Result<'ok, 'error>` | `Ok` value is wrapped in `Some`, lifted to `Task` |
+| `Choice<'ok, 'error>` | Converted to `Result`, then same as `Result` |
+| `'ok option` | `Some`/`None` wrapped in `Ok`, lifted to `Task` |
+| `Async<Result<'ok, 'error>>` | `Ok` value is wrapped in `Some` |
+| `Async<'ok>` | Value is wrapped in `Some` and then `Ok` |

src/FsToolkit.ErrorHandling/TaskResultOption.fs

@@ -33,3 +33,42 @@ module TaskResultOption =
     let inline ignore<'ok, 'error> (tro: Task<Result<'ok option, 'error>>) =
         tro
         |> map ignore<'ok>
+
+    /// <summary>
+    /// Transforms a <c>Result&lt;'ok, 'error&gt;</c> into a <c>Task&lt;Result&lt;'ok option, 'error&gt;&gt;</c>.
+    /// </summary>
+    let inline ofResult (result: Result<'ok, 'error>) : Task<Result<'ok option, 'error>> =
+        result
+        |> Result.map Some
+        |> Task.singleton
+
+    /// <summary>
+    /// Transforms a <c>Task&lt;Result&lt;'ok, 'error&gt;&gt;</c> into a <c>Task&lt;Result&lt;'ok option, 'error&gt;&gt;</c>.
+    /// </summary>
+    let inline ofTaskResult
+        (taskResult: Task<Result<'ok, 'error>>)
+        : Task<Result<'ok option, 'error>> =
+        taskResult
+        |> TaskResult.map Some
+
+    /// <summary>
+    /// Transforms a <c>'ok option</c> into a <c>Task&lt;Result&lt;'ok option, 'error&gt;&gt;</c>.
+    /// </summary>
+    let inline ofOption (option: 'ok option) : Task<Result<'ok option, 'error>> =
+        option
+        |> Ok
+        |> Task.singleton
+
+    /// <summary>
+    /// Transforms a <c>Task&lt;'ok option&gt;</c> into a <c>Task&lt;Result&lt;'ok option, 'error&gt;&gt;</c>.
+    /// </summary>
+    let inline ofTaskOption (taskOption: Task<'ok option>) : Task<Result<'ok option, 'error>> =
+        taskOption
+        |> Task.map Ok
+
+    /// <summary>
+    /// Transforms a <c>Task&lt;'ok&gt;</c> into a <c>Task&lt;Result&lt;'ok option, 'error&gt;&gt;</c>.
+    /// </summary>
+    let inline ofTask (task: Task<'ok>) : Task<Result<'ok option, 'error>> =
+        task
+        |> Task.map (Some >> Ok)

src/FsToolkit.ErrorHandling/TaskResultOptionCE.fs

@@ -250,3 +250,94 @@ module TaskResultOptionCE =
                 TaskResultOptionBuilder.RunDynamic(code)
 
     let taskResultOption = TaskResultOptionBuilder()
+
+[<AutoOpen>]
+module TaskResultOptionCEExtensionsLowPriority =
+    // Low priority extensions - generic catch-alls
+    type TaskResultOptionBuilder with
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(task: Task<'ok>) : TaskResultOption<'ok, 'error> =
+            TaskResultOption.ofTask task
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(computation: Async<'ok>) : TaskResultOption<'ok, 'error> =
+            computation
+            |> Async.StartImmediateAsTask
+            |> TaskResultOption.ofTask
+
+[<AutoOpen>]
+module TaskResultOptionCEExtensions =
+    // Medium-low priority extensions
+    type TaskResultOptionBuilder with
+
+        /// <summary>
+        /// Needed to allow `for..in` and `for..do` functionality
+        /// </summary>
+        member inline _.Source(s: #seq<'value>) : #seq<'value> = s
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(result: Result<'ok, 'error>) : TaskResultOption<'ok, 'error> =
+            TaskResultOption.ofResult result
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline this.Source(result: Choice<'ok, 'error>) : TaskResultOption<'ok, 'error> =
+            this.Source(Result.ofChoice result)
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(option: 'ok option) : TaskResultOption<'ok, 'error> =
+            TaskResultOption.ofOption option
+
+[<AutoOpen>]
+module TaskResultOptionCEExtensionsMediumPriority =
+    // Medium priority extensions - more specific than generic Task/Async
+    type TaskResultOptionBuilder with
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source
+            (asyncResult: Async<Result<'ok, 'error>>)
+            : TaskResultOption<'ok, 'error> =
+            asyncResult
+            |> Async.StartImmediateAsTask
+            |> TaskResultOption.ofTaskResult
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(taskOption: Task<'ok option>) : TaskResultOption<'ok, 'error> =
+            TaskResultOption.ofTaskOption taskOption
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source
+            (taskResult: Task<Result<'ok, 'error>>)
+            : TaskResultOption<'ok, 'error> =
+            TaskResultOption.ofTaskResult taskResult
+
+[<AutoOpen>]
+module TaskResultOptionCEExtensionsHighPriority =
+    // High priority extensions - identity for the self type
+    type TaskResultOptionBuilder with
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.  This is the identity method to recognize the self type.
+        ///
+        /// See https://stackoverflow.com/questions/35286541/why-would-you-use-builder-source-in-a-custom-computation-expression-builder
+        /// </summary>
+        member inline _.Source
+            (result: TaskResultOption<'ok, 'error>)
+            : TaskResultOption<'ok, 'error> =
+            result

tests/FsToolkit.ErrorHandling.Tests/TaskResultOption.fs

@@ -259,6 +259,121 @@ let ``TaskResultOptionCE inference checks`` =
             |> ignore
     ]
 
+let computationExpressionSourceTests =
+    testList "taskResultOption CE Source Tests" [
+        testCase "Bind Result.Ok"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Result.Ok "Foo"
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind Result.Error"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Result.Error "error"
+                return value
+            }
+            |> Expect.hasTaskErrorValueSync "error"
+
+        testCase "Bind Choice1Of2"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Choice1Of2 "Foo"
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind Choice2Of2"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Choice2Of2 "error"
+                return value
+            }
+            |> Expect.hasTaskErrorValueSync "error"
+
+        testCase "Bind Some"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Some "Foo"
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind None"
+        <| fun _ ->
+            taskResultOption {
+                let! value = (None: string option)
+                return value
+            }
+            |> Expect.hasTaskOkValueSync None
+
+        testCase "Bind TaskResult Ok"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Task.FromResult(Ok "Foo")
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind TaskResult Error"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Task.FromResult(Error "error")
+                return value
+            }
+            |> Expect.hasTaskErrorValueSync "error"
+
+        testCase "Bind TaskOption Some"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Task.FromResult(Some "Foo")
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind TaskOption None"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Task.FromResult(None: string option)
+                return value
+            }
+            |> Expect.hasTaskOkValueSync None
+
+        testCase "Bind Task<'T>"
+        <| fun _ ->
+            taskResultOption {
+                let! value = Task.FromResult "Foo"
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind AsyncResult Ok"
+        <| fun _ ->
+            taskResultOption {
+                let! value = async { return Ok "Foo" }
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+
+        testCase "Bind AsyncResult Error"
+        <| fun _ ->
+            taskResultOption {
+                let! value = async { return Error "error" }
+                return value
+            }
+            |> Expect.hasTaskErrorValueSync "error"
+
+        testCase "Bind Async<'T>"
+        <| fun _ ->
+            taskResultOption {
+                let! value = async { return "Foo" }
+                return value
+            }
+            |> Expect.hasTaskOkValueSync (Some "Foo")
+    ]
+
 let allTests =
     testList "TaskResultOption Tests" [
         mapTests
@@ -268,4 +383,5 @@ let allTests =
         computationExpressionTests
         operatorTests
         ``TaskResultOptionCE inference checks``
+        computationExpressionSourceTests
     ]