Adds CancellableResultTask functions (#203)

* updates IcedTasks to 0.5.1

* Adds helpers to CancellableTaskResult

Author: TheAngryByrd

paket.dependencies

@@ -47,7 +47,7 @@ nuget Microsoft.NET.Test.Sdk
 nuget YoloDev.Expecto.TestSdk
 nuget Fable.Mocha
 nuget Fable.Core >= 4.0.0-theta-006
-nuget IcedTasks >= 0.5.0
+nuget IcedTasks >= 0.5.1
 framework: netstandard2.1, net7.0
 storage: none
 condition: netstandard2_1

paket.lock

@@ -1026,7 +1026,7 @@ NUGET
     FSharp.Core (7.0)
     Hopac (0.5.1)
       FSharp.Core (>= 4.5.2)
-    IcedTasks (0.5)
+    IcedTasks (0.5.1)
       FSharp.Core (>= 7.0)
     Microsoft.Bcl.AsyncInterfaces (6.0)
     Microsoft.CodeCoverage (17.4) - restriction: || (== net7.0) (&& (== netstandard2.1) (>= net462)) (&& (== netstandard2.1) (>= netcoreapp3.1))

src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskResultCE.fs

@@ -770,3 +770,81 @@ module CancellableTaskResultCE =
                     true
                 )
             )
+
+        /// <summary>Lifts an item to a CancellableTaskResult.</summary>
+        /// <param name="item">The item to be the result of the CancellableTaskResult.</param>
+        /// <returns>A CancellableTaskResult with the item as the result.</returns>
+        let inline singleton (item: 'item) : CancellableTaskResult<'item, 'Error> =
+            fun _ -> Task.FromResult(Ok item)
+
+
+        /// <summary>Allows chaining of CancellableTaskResult.</summary>
+        /// <param name="binder">The continuation.</param>
+        /// <param name="cTask">The value.</param>
+        /// <returns>The result of the binder.</returns>
+        let inline bind
+            ([<InlineIfLambda>] binder: 'input -> CancellableTaskResult<'output, 'error>)
+            ([<InlineIfLambda>] cTask: CancellableTaskResult<'input, 'error>)
+            =
+            cancellableTaskResult {
+                let! cResult = cTask
+                return! binder cResult
+            }
+
+        /// <summary>Allows chaining of CancellableTaskResult.</summary>
+        /// <param name="mapper">The continuation.</param>
+        /// <param name="cTask">The value.</param>
+        /// <returns>The result of the mapper wrapped in a CancellableTaskResult.</returns>
+        let inline map
+            ([<InlineIfLambda>] mapper: 'input -> 'output)
+            ([<InlineIfLambda>] cTask: CancellableTaskResult<'input, 'error>)
+            =
+            cancellableTaskResult {
+                let! cResult = cTask
+                return mapper cResult
+            }
+
+        /// <summary>Allows chaining of CancellableTaskResult.</summary>
+        /// <param name="applicable">A function wrapped in a CancellableTaskResult</param>
+        /// <param name="cTask">The value.</param>
+        /// <returns>The result of the applicable.</returns>
+        let inline apply
+            ([<InlineIfLambda>] applicable: CancellableTaskResult<'input -> 'output, 'error>)
+            ([<InlineIfLambda>] cTask: CancellableTaskResult<'input, 'error>)
+            =
+            cancellableTaskResult {
+                let! applier = applicable
+                let! cResult = cTask
+                return applier cResult
+            }
+
+        /// <summary>Takes two CancellableTaskResult, starts them serially in order of left to right, and returns a tuple of the pair.</summary>
+        /// <param name="left">The left value.</param>
+        /// <param name="right">The right value.</param>
+        /// <returns>A tuple of the parameters passed in</returns>
+        let inline zip
+            ([<InlineIfLambda>] left: CancellableTaskResult<'left, 'error>)
+            ([<InlineIfLambda>] right: CancellableTaskResult<'right, 'error>)
+            =
+            cancellableTaskResult {
+                let! r1 = left
+                let! r2 = right
+                return r1, r2
+            }
+
+        /// <summary>Takes two CancellableTaskResult, starts them concurrently, and returns a tuple of the pair.</summary>
+        /// <param name="left">The left value.</param>
+        /// <param name="right">The right value.</param>
+        /// <returns>A tuple of the parameters passed in.</returns>
+        let inline parallelZip
+            ([<InlineIfLambda>] left: CancellableTaskResult<'left, 'error>)
+            ([<InlineIfLambda>] right: CancellableTaskResult<'right, 'error>)
+            =
+            cancellableTaskResult {
+                let! ct = getCancellationToken ()
+                let r1 = left ct
+                let r2 = right ct
+                let! r1 = r1
+                let! r2 = r2
+                return r1, r2
+            }

tests/FsToolkit.ErrorHandling.IcedTasks.Tests/CancellableTaskResultCE.fs

@@ -56,7 +56,7 @@ module CancellableTaskResultCE =
             member this.Dispose() = ()
         }
 
-    [<Tests>]
+
     let cancellableTaskResultBuilderTests =
         testList "CancellableTaskResultBuilder" [
             testList "Return" [
@@ -923,3 +923,92 @@ module CancellableTaskResultCE =
 
             ]
         ]
+
+    let functionTests =
+        testList "functions" [
+            testList "singleton" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = CancellableTaskResult.singleton "lol"
+
+                    let! someTask = innerCall
+
+                    Expect.equal (Ok "lol") someTask ""
+                }
+            ]
+            testList "bind" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = cancellableTaskResult { return "lol" }
+
+                    let! someTask =
+                        innerCall
+                        |> CancellableTaskResult.bind (fun x -> cancellableTaskResult {
+                            return x + "fooo"
+                        }
+                        )
+
+                    Expect.equal (Ok "lolfooo") someTask ""
+                }
+            ]
+            testList "map" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = cancellableTaskResult { return "lol" }
+
+                    let! someTask =
+                        innerCall
+                        |> CancellableTaskResult.map (fun x -> x + "fooo")
+
+                    Expect.equal (Ok "lolfooo") someTask ""
+                }
+            ]
+            testList "apply" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = cancellableTaskResult { return "lol" }
+                    let applier = cancellableTaskResult { return fun x -> x + "fooo" }
+
+                    let! someTask =
+                        innerCall
+                        |> CancellableTaskResult.apply applier
+
+                    Expect.equal (Ok "lolfooo") someTask ""
+                }
+            ]
+
+            testList "zip" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = cancellableTaskResult { return "fooo" }
+                    let innerCall2 = cancellableTaskResult { return "lol" }
+
+                    let! someTask =
+                        innerCall
+                        |> CancellableTaskResult.zip innerCall2
+
+                    Expect.equal (Ok("lol", "fooo")) someTask ""
+                }
+            ]
+
+            testList "parZip" [
+                testCaseAsync "Simple"
+                <| async {
+                    let innerCall = cancellableTaskResult { return "fooo" }
+                    let innerCall2 = cancellableTaskResult { return "lol" }
+
+                    let! someTask =
+                        innerCall
+                        |> CancellableTaskResult.parallelZip innerCall2
+
+                    Expect.equal (Ok("lol", "fooo")) someTask ""
+                }
+            ]
+        ]
+
+    [<Tests>]
+    let cancellableTaskResultTests =
+        testList "CancellableTaskResult" [
+            cancellableTaskResultBuilderTests
+            functionTests
+        ]