diff --git a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/Expecto.fs b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/Expecto.fs index a00c1ff4..29971f75 100644 --- a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/Expecto.fs +++ b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/Expecto.fs @@ -4,10 +4,10 @@ open Expecto open FsToolkit.ErrorHandling let testCaseTask name test = - testCaseAsync name (Async.AwaitTask test) + testCaseAsync name (async { return! test () |> Async.AwaitTask }) let ptestCaseTask name test = - ptestCaseAsync name (Async.AwaitTask test) + ptestCaseAsync name (async { return! test () |> Async.AwaitTask }) let ftestCaseTask name test = - ftestCaseAsync name (Async.AwaitTask test) + ftestCaseAsync name (async { return! test () |> Async.AwaitTask }) diff --git a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskOptionCE.fs b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskOptionCE.fs index db8da08d..bac6dab6 100644 --- a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskOptionCE.fs +++ b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskOptionCE.fs @@ -14,322 +14,352 @@ let ceTests = testList "Task CE" [ testCaseTask "Return value" - <| task { - let expected = Some 42 - let! actual = taskOption { return 42 } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + let! actual = taskOption { return 42 } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Some" - <| task { - let expected = Some 42 - let! actual = taskOption { return! (Some 42) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + let! actual = taskOption { return! (Some 42) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom None" - <| task { - let expected = None - let! actual = taskOption { return! None } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = None + let! actual = taskOption { return! None } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Async None" - <| task { - let expected = None - let! actual = taskOption { return! (async.Return None) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = None + let! actual = taskOption { return! (async.Return None) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Async" - <| task { - let expected = Some 42 - let! actual = taskOption { return! (async.Return 42) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + let! actual = taskOption { return! (async.Return 42) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Task None" - <| task { - let expected = None - let! actual = taskOption { return! (Task.FromResult None) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = None + let! actual = taskOption { return! (Task.FromResult None) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Task Generic" - <| task { - let expected = Some 42 - let! actual = taskOption { return! (Task.FromResult 42) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + let! actual = taskOption { return! (Task.FromResult 42) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom Task" - <| task { - let expected = Some() - let! actual = taskOption { return! Task.CompletedTask } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some() + let! actual = taskOption { return! Task.CompletedTask } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom ValueTask Generic" - <| task { - let expected = Some 42 - let! actual = taskOption { return! (ValueTask.FromResult 42) } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + let! actual = taskOption { return! (ValueTask.FromResult 42) } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "ReturnFrom ValueTask" - <| task { - let expected = Some() - let! actual = taskOption { return! ValueTask.CompletedTask } - Expect.equal actual expected "Should return value wrapped in option" - } + <| fun () -> + task { + let expected = Some() + let! actual = taskOption { return! ValueTask.CompletedTask } + Expect.equal actual expected "Should return value wrapped in option" + } testCaseTask "Bind Some" - <| task { - let expected = Some 42 - - let! actual = - taskOption { - let! value = Some 42 - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + + let! actual = + taskOption { + let! value = Some 42 + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind None" - <| task { - let expected = None - - let! actual = - taskOption { - let! value = None - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = None + + let! actual = + taskOption { + let! value = None + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind Async None" - <| task { - let expected = None - - let! actual = - taskOption { - let! value = async.Return(None) - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = None + + let! actual = + taskOption { + let! value = async.Return(None) + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind Async" - <| task { - let expected = Some 42 - - let! actual = - taskOption { - let! value = async.Return 42 - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + + let! actual = + taskOption { + let! value = async.Return 42 + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind Task None" - <| task { - let expected = None - - let! actual = - taskOption { - let! value = Task.FromResult None - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = None + + let! actual = + taskOption { + let! value = Task.FromResult None + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind Task Generic" - <| task { - let expected = Some 42 - - let! actual = - taskOption { - let! value = Task.FromResult 42 - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + + let! actual = + taskOption { + let! value = Task.FromResult 42 + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind Task" - <| task { - let expected = Some() - - let! actual = - taskOption { - let! value = Task.CompletedTask - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some() + + let! actual = + taskOption { + let! value = Task.CompletedTask + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind ValueTask Generic" - <| task { - let expected = Some 42 - - let! actual = - taskOption { - let! value = ValueTask.FromResult 42 - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some 42 + + let! actual = + taskOption { + let! value = ValueTask.FromResult 42 + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Bind ValueTask" - <| task { - let expected = Some() - - let! actual = - taskOption { - let! value = ValueTask.CompletedTask - return value - } - - Expect.equal actual expected "Should bind value wrapped in option" - } + <| fun () -> + task { + let expected = Some() + + let! actual = + taskOption { + let! value = ValueTask.CompletedTask + return value + } + + Expect.equal actual expected "Should bind value wrapped in option" + } testCaseTask "Zero/Combine/Delay/Run" - <| task { - let data = 42 - - let! actual = - taskOption { - let result = data - if true then () - return result - } - - Expect.equal actual (Some data) "Should be ok" - } + <| fun () -> + task { + let data = 42 + + let! actual = + taskOption { + let result = data + if true then () + return result + } + + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "Try With" - <| task { - let data = 42 - - let! actual = - taskOption { - try - return data - with - | e -> return raise e - } - - Expect.equal actual (Some data) "Try with failed" - } + <| fun () -> + task { + let data = 42 + + let! actual = + taskOption { + try + return data + with + | e -> return raise e + } + + Expect.equal actual (Some data) "Try with failed" + } testCaseTask "Try Finally" - <| task { - let data = 42 - - let! actual = - taskOption { - try - return data - finally - () - } - - Expect.equal actual (Some data) "Try with failed" - } + <| fun () -> + task { + let data = 42 + + let! actual = + taskOption { + try + return data + finally + () + } + + Expect.equal actual (Some data) "Try with failed" + } testCaseTask "Using null" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskOption { - use d = null - return data - } + let! actual = + taskOption { + use d = null + return data + } - Expect.equal actual (Some data) "Should be ok" - } + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "Using disposeable" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskOption { - use d = makeDisposable () - return data - } + let! actual = + taskOption { + use d = makeDisposable () + return data + } - Expect.equal actual (Some data) "Should be ok" - } + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "Using bind disposeable" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskOption { - use! d = (makeDisposable () |> Some) - return data - } + let! actual = + taskOption { + use! d = (makeDisposable () |> Some) + return data + } - Expect.equal actual (Some data) "Should be ok" - } + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "While" - <| task { - let data = 42 - let mutable index = 0 + <| fun () -> + task { + let data = 42 + let mutable index = 0 - let! actual = - taskOption { - while index < 10 do - index <- index + 1 + let! actual = + taskOption { + while index < 10 do + index <- index + 1 - return data - } + return data + } - Expect.equal actual (Some data) "Should be ok" - } + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "For in" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskOption { - for i in [ 1 .. 10 ] do - () + let! actual = + taskOption { + for i in [ 1 .. 10 ] do + () - return data - } + return data + } - Expect.equal actual (Some data) "Should be ok" - } + Expect.equal actual (Some data) "Should be ok" + } testCaseTask "For to" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskOption { - for i = 1 to 10 do - () + let! actual = + taskOption { + for i = 1 to 10 do + () - return data - } + return data + } - Expect.equal actual (Some data) "Should be ok" - } ] + Expect.equal actual (Some data) "Should be ok" + } ] [] let ceTestsApplicative = testList "TaskOptionCE applicative tests" [ testCaseTask "Happy Path Option/AsyncOption/Ply/ValueTask" - <| task { - let! actual = - taskOption { - let! a = Some 3 - let! b = Some 1 |> Async.singleton - let! c = Unsafe.uply { return Some 3 } - let! d = ValueTask.FromResult(Some 5) - return a + b - c - d - } - - Expect.equal actual (Some -4) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskOption { + let! a = Some 3 + let! b = Some 1 |> Async.singleton + let! c = Unsafe.uply { return Some 3 } + let! d = ValueTask.FromResult(Some 5) + return a + b - c - d + } + + Expect.equal actual (Some -4) "Should be ok" + } testCaseTask "Fail Path Option/AsyncOption/Ply/ValueTask" - <| task { - let! actual = - taskOption { - let! a = Some 3 - and! b = Some 1 |> Async.singleton - and! c = Unsafe.uply { return None } - and! d = ValueTask.FromResult(Some 5) - return a + b - c - d - } - - Expect.equal actual None "Should be ok" - } ] + <| fun () -> + task { + let! actual = + taskOption { + let! a = Some 3 + and! b = Some 1 |> Async.singleton + and! c = Unsafe.uply { return None } + and! d = ValueTask.FromResult(Some 5) + return a + b - c - d + } + + Expect.equal actual None "Should be ok" + } ] diff --git a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResult.fs b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResult.fs index 9737165c..acffc9e5 100644 --- a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResult.fs +++ b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResult.fs @@ -151,66 +151,74 @@ let orElseTests = testList "TaskResult.orElseWith Tests" [ testCaseTask "Ok Ok takes first Ok" - <| task { - do! - TaskResult.ok "First" - |> TaskResult.orElse (TaskResult.ok "Second") - |> Expect.hasTaskOkValue "First" - } + <| fun () -> + task { + do! + TaskResult.ok "First" + |> TaskResult.orElse (TaskResult.ok "Second") + |> Expect.hasTaskOkValue "First" + } testCaseTask "Ok Error takes first Ok" - <| task { - return! - TaskResult.ok "First" - |> TaskResult.orElse (TaskResult.error "Second") - |> Expect.hasTaskOkValue "First" - } + <| fun () -> + task { + return! + TaskResult.ok "First" + |> TaskResult.orElse (TaskResult.error "Second") + |> Expect.hasTaskOkValue "First" + } testCaseTask "Error Ok takes second Ok" - <| task { - return! - TaskResult.error "First" - |> TaskResult.orElse (TaskResult.ok "Second") - |> Expect.hasTaskOkValue "Second" - } + <| fun () -> + task { + return! + TaskResult.error "First" + |> TaskResult.orElse (TaskResult.ok "Second") + |> Expect.hasTaskOkValue "Second" + } testCaseTask "Error Error takes second error" - <| task { - return! - TaskResult.error "First" - |> TaskResult.orElse (TaskResult.error "Second") - |> Expect.hasTaskErrorValue "Second" - } ] + <| fun () -> + task { + return! + TaskResult.error "First" + |> TaskResult.orElse (TaskResult.error "Second") + |> Expect.hasTaskErrorValue "Second" + } ] [] let orElseWithTests = testList "TaskResult.orElse Tests" [ testCaseTask "Ok Ok takes first Ok" - <| task { - return! - TaskResult.ok "First" - |> TaskResult.orElseWith (fun _ -> TaskResult.ok "Second") - |> Expect.hasTaskOkValue "First" - } + <| fun () -> + task { + return! + TaskResult.ok "First" + |> TaskResult.orElseWith (fun _ -> TaskResult.ok "Second") + |> Expect.hasTaskOkValue "First" + } testCaseTask "Ok Error takes first Ok" - <| task { - return! - TaskResult.ok "First" - |> TaskResult.orElseWith (fun _ -> TaskResult.error "Second") - |> Expect.hasTaskOkValue "First" - } + <| fun () -> + task { + return! + TaskResult.ok "First" + |> TaskResult.orElseWith (fun _ -> TaskResult.error "Second") + |> Expect.hasTaskOkValue "First" + } testCaseTask "Error Ok takes second Ok" - <| task { - return! - TaskResult.error "First" - |> TaskResult.orElseWith (fun _ -> TaskResult.ok "Second") - |> Expect.hasTaskOkValue "Second" - } + <| fun () -> + task { + return! + TaskResult.error "First" + |> TaskResult.orElseWith (fun _ -> TaskResult.ok "Second") + |> Expect.hasTaskOkValue "Second" + } testCaseTask "Error Error takes second error" - <| task { - return! - TaskResult.error "First" - |> TaskResult.orElseWith (fun _ -> TaskResult.error "Second") - |> Expect.hasTaskErrorValue "Second" - } ] + <| fun () -> + task { + return! + TaskResult.error "First" + |> TaskResult.orElseWith (fun _ -> TaskResult.error "Second") + |> Expect.hasTaskErrorValue "Second" + } ] [] let ignoreTests = diff --git a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResultCE.fs b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResultCE.fs index 14bee40d..1e87160e 100644 --- a/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResultCE.fs +++ b/tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResultCE.fs @@ -14,11 +14,12 @@ let ``TaskResultCE return Tests`` = testList "TaskResultCE Tests" [ testCaseTask "Return string" - <| task { - let data = "Foo" - let! actual = taskResult { return data } - Expect.equal actual (Result.Ok data) "Should be ok" - } ] + <| fun () -> + task { + let data = "Foo" + let! actual = taskResult { return data } + Expect.equal actual (Result.Ok data) "Should be ok" + } ] [] @@ -26,78 +27,88 @@ let ``TaskResultCE return! Tests`` = testList "TaskResultCE return! Tests" [ testCaseTask "Return Ok Result" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData - let! actual = taskResult { return! data } - - Expect.equal actual (data) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData + let! actual = taskResult { return! data } + + Expect.equal actual (data) "Should be ok" + } testCaseTask "Return Ok Choice" - <| task { - let innerData = "Foo" - let data = Choice1Of2 innerData - let! actual = taskResult { return! data } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Choice1Of2 innerData + let! actual = taskResult { return! data } + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Return Ok AsyncResult" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData - let! actual = taskResult { return! Async.singleton data } - - Expect.equal actual (data) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData + let! actual = taskResult { return! Async.singleton data } + + Expect.equal actual (data) "Should be ok" + } testCaseTask "Return Ok TaskResult" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData - let! actual = taskResult { return! Task.FromResult data } - - Expect.equal actual (data) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData + let! actual = taskResult { return! Task.FromResult data } + + Expect.equal actual (data) "Should be ok" + } testCaseTask "Return Async" - <| task { - let innerData = "Foo" - let! actual = taskResult { return! Async.singleton innerData } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { return! Async.singleton innerData } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Return Task Generic" - <| task { - let innerData = "Foo" - let! actual = taskResult { return! Task.singleton innerData } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { return! Task.singleton innerData } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Return Task" - <| task { - let innerData = "Foo" - let! actual = taskResult { return! Task.FromResult innerData :> Task } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { return! Task.FromResult innerData :> Task } - Expect.equal actual (Result.Ok()) "Should be ok" - } + Expect.equal actual (Result.Ok()) "Should be ok" + } testCaseTask "Return ValueTask Generic" - <| task { - let innerData = "Foo" - let! actual = taskResult { return! ValueTask.FromResult innerData } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { return! ValueTask.FromResult innerData } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Return ValueTask" - <| task { - let! actual = taskResult { return! ValueTask.CompletedTask } + <| fun () -> + task { + let! actual = taskResult { return! ValueTask.CompletedTask } - Expect.equal actual (Result.Ok()) "Should be ok" - } + Expect.equal actual (Result.Ok()) "Should be ok" + } testCaseTask "Return Ply" - <| task { - let innerData = "Foo" - let! actual = taskResult { return! Unsafe.uply { return innerData } } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { return! Unsafe.uply { return innerData } } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } ] + Expect.equal actual (Result.Ok innerData) "Should be ok" + } ] [] @@ -105,121 +116,131 @@ let ``TaskResultCE bind Tests`` = testList "TaskResultCE bind Tests" [ testCaseTask "Bind Ok Result" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData - let! actual = - taskResult { - let! data = data - return data - } + let! actual = + taskResult { + let! data = data + return data + } - Expect.equal actual (data) "Should be ok" + Expect.equal actual (data) "Should be ok" - } + } testCaseTask "Bind Ok Choice" - <| task { - let innerData = "Foo" - let data = Choice1Of2 innerData + <| fun () -> + task { + let innerData = "Foo" + let data = Choice1Of2 innerData - let! actual = - taskResult { - let! data = data - return data - } + let! actual = + taskResult { + let! data = data + return data + } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Bind Ok AsyncResult" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData |> Async.singleton - - let! actual = - taskResult { - let! data = data - return data - } - - Expect.equal actual (data |> Async.RunSynchronously) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData |> Async.singleton + + let! actual = + taskResult { + let! data = data + return data + } + + Expect.equal actual (data |> Async.RunSynchronously) "Should be ok" + } testCaseTask "Bind Ok TaskResult" - <| task { - let innerData = "Foo" - let data = Result.Ok innerData |> Task.singleton - - let! actual = - taskResult { - let! data = data - return data - } - - Expect.equal actual (data.Result) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + let data = Result.Ok innerData |> Task.singleton + + let! actual = + taskResult { + let! data = data + return data + } + + Expect.equal actual (data.Result) "Should be ok" + } testCaseTask "Bind Async" - <| task { - let innerData = "Foo" - - let! actual = - taskResult { - let! data = Async.singleton innerData - return data - } - - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + + let! actual = + taskResult { + let! data = Async.singleton innerData + return data + } + + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Bind Task Generic" - <| task { - let innerData = "Foo" - - let! actual = - taskResult { - let! data = Task.FromResult innerData - return data - } - - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + + let! actual = + taskResult { + let! data = Task.FromResult innerData + return data + } + + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Bind Task" - <| task { - let innerData = "Foo" - let! actual = taskResult { do! Task.FromResult innerData :> Task } + <| fun () -> + task { + let innerData = "Foo" + let! actual = taskResult { do! Task.FromResult innerData :> Task } - Expect.equal actual (Result.Ok()) "Should be ok" - } + Expect.equal actual (Result.Ok()) "Should be ok" + } testCaseTask "Bind ValueTask Generic" - <| task { - let innerData = "Foo" - - let! actual = - taskResult { - let! data = ValueTask.FromResult innerData - return data - } - - Expect.equal actual (Result.Ok innerData) "Should be ok" - } + <| fun () -> + task { + let innerData = "Foo" + + let! actual = + taskResult { + let! data = ValueTask.FromResult innerData + return data + } + + Expect.equal actual (Result.Ok innerData) "Should be ok" + } testCaseTask "Bind ValueTask" - <| task { - let! actual = taskResult { do! ValueTask.CompletedTask } + <| fun () -> + task { + let! actual = taskResult { do! ValueTask.CompletedTask } - Expect.equal actual (Result.Ok()) "Should be ok" - } + Expect.equal actual (Result.Ok()) "Should be ok" + } testCaseTask "Bind Ply" - <| task { - let innerData = "Foo" + <| fun () -> + task { + let innerData = "Foo" - let! actual = - taskResult { - let! data = Unsafe.uply { return innerData } - return data - } + let! actual = + taskResult { + let! data = Unsafe.uply { return innerData } + return data + } - Expect.equal actual (Result.Ok innerData) "Should be ok" - } ] + Expect.equal actual (Result.Ok innerData) "Should be ok" + } ] [] @@ -227,18 +248,19 @@ let ``TaskResultCE combine/zero/delay/run Tests`` = testList "TaskResultCE combine/zero/delay/run Tests" [ testCaseTask "Zero/Combine/Delay/Run" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - let result = data - if true then () - return result - } + let! actual = + taskResult { + let result = data + if true then () + return result + } - Expect.equal actual (Result.Ok data) "Should be ok" - } ] + Expect.equal actual (Result.Ok data) "Should be ok" + } ] @@ -247,41 +269,43 @@ let ``TaskResultCE try Tests`` = testList "TaskResultCE try Tests" [ testCaseTask "Try With" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - let data = data + let! actual = + taskResult { + let data = data - try - () - with - | _ -> () + try + () + with + | _ -> () - return data - } + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "Try Finally" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - let data = data + let! actual = + taskResult { + let data = data - try - () - finally - () + try + () + finally + () - return data - } + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } ] + Expect.equal actual (Result.Ok data) "Should be ok" + } ] let makeDisposable () = { new System.IDisposable with @@ -292,41 +316,44 @@ let ``TaskResultCE using Tests`` = testList "TaskResultCE using Tests" [ testCaseTask "use normal disposable" - <| task { - let data = 42 - - let! actual = - taskResult { - use d = makeDisposable () - return data - } - - Expect.equal actual (Result.Ok data) "Should be ok" - } + <| fun () -> + task { + let data = 42 + + let! actual = + taskResult { + use d = makeDisposable () + return data + } + + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "use! normal wrapped disposable" - <| task { - let data = 42 - - let! actual = - taskResult { - use! d = makeDisposable () |> Result.Ok - return data - } - - Expect.equal actual (Result.Ok data) "Should be ok" - } + <| fun () -> + task { + let data = 42 + + let! actual = + taskResult { + use! d = makeDisposable () |> Result.Ok + return data + } + + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "use null disposable" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - use d = null - return data - } + let! actual = + taskResult { + use d = null + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } ] + Expect.equal actual (Result.Ok data) "Should be ok" + } ] [] @@ -334,73 +361,77 @@ let ``TaskResultCE loop Tests`` = testList "TaskResultCE loop Tests" [ testCaseTask "while" - <| task { - let data = 42 - let mutable index = 0 + <| fun () -> + task { + let data = 42 + let mutable index = 0 - let! actual = - taskResult { - while index < 10 do - index <- index + 1 + let! actual = + taskResult { + while index < 10 do + index <- index + 1 - return data - } + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "for in" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - for i in [ 1 .. 10 ] do - () + let! actual = + taskResult { + for i in [ 1 .. 10 ] do + () - return data - } + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "for to" - <| task { - let data = 42 + <| fun () -> + task { + let data = 42 - let! actual = - taskResult { - for i = 1 to 10 do - () + let! actual = + taskResult { + for i = 1 to 10 do + () - return data - } + return data + } - Expect.equal actual (Result.Ok data) "Should be ok" - } + Expect.equal actual (Result.Ok data) "Should be ok" + } testCaseTask "for in fail" - <| task { + <| fun () -> + task { - let mutable loopCount = 0 - let expected = Error "error" + let mutable loopCount = 0 + let expected = Error "error" - let data = - [ Ok "42" - Ok "1024" - expected - Ok "1M" ] + let data = + [ Ok "42" + Ok "1024" + expected + Ok "1M" ] - let! actual = - taskResult { - for i in data do - let! x = i - loopCount <- loopCount + 1 - () + let! actual = + taskResult { + for i in data do + let! x = i + loopCount <- loopCount + 1 + () - return "ok" - } + return "ok" + } - Expect.equal 2 loopCount "Should only loop twice" - Expect.equal actual expected "Should be and error" - } ] + Expect.equal 2 loopCount "Should only loop twice" + Expect.equal actual expected "Should be and error" + } ] [] @@ -408,151 +439,162 @@ let ``TaskResultCE applicative tests`` = testList "TaskResultCE applicative tests" [ testCaseTask "Happy Path TaskResult" - <| task { - let! actual = - taskResult { - let! a = TaskResult.retn 3 - and! b = TaskResult.retn 2 - and! c = TaskResult.retn 1 - return a + b - c - } - - Expect.equal actual (Ok 4) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = TaskResult.retn 3 + and! b = TaskResult.retn 2 + and! c = TaskResult.retn 1 + return a + b - c + } + + Expect.equal actual (Ok 4) "Should be ok" + } testCaseTask "Happy Path AsyncResult" - <| task { - let! actual = - taskResult { - let! a = AsyncResult.retn 3 - and! b = AsyncResult.retn 2 - and! c = AsyncResult.retn 1 - return a + b - c - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = AsyncResult.retn 3 + and! b = AsyncResult.retn 2 + and! c = AsyncResult.retn 1 + return a + b - c + } - Expect.equal actual (Ok 4) "Should be ok" - } + Expect.equal actual (Ok 4) "Should be ok" + } testCaseTask "Happy Path Result" - <| task { - let! actual = - taskResult { - let! a = Result.Ok 3 - and! b = Result.Ok 2 - and! c = Result.Ok 1 - return a + b - c - } - - Expect.equal actual (Ok 4) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Result.Ok 3 + and! b = Result.Ok 2 + and! c = Result.Ok 1 + return a + b - c + } + + Expect.equal actual (Ok 4) "Should be ok" + } testCaseTask "Happy Path Choice" - <| task { - let! actual = - taskResult { - let! a = Choice1Of2 3 - and! b = Choice1Of2 2 - and! c = Choice1Of2 1 - return a + b - c - } - - Expect.equal actual (Ok 4) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Choice1Of2 3 + and! b = Choice1Of2 2 + and! c = Choice1Of2 1 + return a + b - c + } + + Expect.equal actual (Ok 4) "Should be ok" + } testCaseTask "Happy Path Async" - <| task { - let! actual = - taskResult { - let! a = Async.singleton 3 //: Async - and! b = Async.singleton 2 //: Async - and! c = Async.singleton 1 //: Async - return a + b - c - } - - Expect.equal actual (Ok 4) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Async.singleton 3 //: Async + and! b = Async.singleton 2 //: Async + and! c = Async.singleton 1 //: Async + return a + b - c + } + + Expect.equal actual (Ok 4) "Should be ok" + } testCaseTask "Happy Path 2 Async" - <| task { - let! actual = - taskResult { - let! a = Async.singleton 3 //: Async - and! b = Async.singleton 2 //: Async - return a + b - } - - Expect.equal actual (Ok 5) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Async.singleton 3 //: Async + and! b = Async.singleton 2 //: Async + return a + b + } + + Expect.equal actual (Ok 5) "Should be ok" + } testCaseTask "Happy Path 2 Task" - <| task { - let! actual = - taskResult { - let! a = Task.FromResult 3 - and! b = Task.FromResult 2 - return a + b - } - - Expect.equal actual (Ok 5) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Task.FromResult 3 + and! b = Task.FromResult 2 + return a + b + } + + Expect.equal actual (Ok 5) "Should be ok" + } testCaseTask "Happy Path Result/Choice/AsyncResult/Ply/ValueTask" - <| task { - let! actual = - taskResult { - let! a = Ok 3 - and! b = Choice1Of2 2 - and! c = Ok 1 |> Async.singleton - and! d = Unsafe.uply { return Ok 3 } - and! e = ValueTask.FromResult(Ok 5) - return a + b - c - d + e - } - - Expect.equal actual (Ok 6) "Should be ok" - } + <| fun () -> + task { + let! actual = + taskResult { + let! a = Ok 3 + and! b = Choice1Of2 2 + and! c = Ok 1 |> Async.singleton + and! d = Unsafe.uply { return Ok 3 } + and! e = ValueTask.FromResult(Ok 5) + return a + b - c - d + e + } + + Expect.equal actual (Ok 6) "Should be ok" + } testCaseTask "Fail Path Result" - <| task { - let expected = Error "TryParse failure" + <| fun () -> + task { + let expected = Error "TryParse failure" - let! actual = - taskResult { - let! a = Ok 3 - and! b = Ok 2 - and! c = expected - return a + b - c - } + let! actual = + taskResult { + let! a = Ok 3 + and! b = Ok 2 + and! c = expected + return a + b - c + } - Expect.equal actual expected "Should be Error" - } + Expect.equal actual expected "Should be Error" + } testCaseTask "Fail Path Choice" - <| task { - let errorMsg = "TryParse failure" + <| fun () -> + task { + let errorMsg = "TryParse failure" - let! actual = - taskResult { - let! a = Choice1Of2 3 - and! b = Choice1Of2 2 - and! c = Choice2Of2 errorMsg - return a + b - c - } + let! actual = + taskResult { + let! a = Choice1Of2 3 + and! b = Choice1Of2 2 + and! c = Choice2Of2 errorMsg + return a + b - c + } - Expect.equal actual (Error errorMsg) "Should be Error" - } + Expect.equal actual (Error errorMsg) "Should be Error" + } testCaseTask "Fail Path Result/Choice/AsyncResult" - <| task { - let errorMsg = "TryParse failure" - - let! actual = - taskResult { - let! a = Choice1Of2 3 - and! b = Ok 2 |> Async.singleton - and! c = Error errorMsg - return a + b - c - } - - Expect.equal actual (Error errorMsg) "Should be Error" - } ] + <| fun () -> + task { + let errorMsg = "TryParse failure" + + let! actual = + taskResult { + let! a = Choice1Of2 3 + and! b = Ok 2 |> Async.singleton + and! c = Error errorMsg + return a + b - c + } + + Expect.equal actual (Error errorMsg) "Should be Error" + } ]