Extend Option.either (#198)

Author: TheAngryByrd

src/FsToolkit.ErrorHandling.JobResult/JobOption.fs

@@ -23,3 +23,25 @@ module JobOption =
 
     let inline apply f x =
         bind (fun f' -> bind (fun x' -> retn (f' x')) x) f
+
+
+    /// <summary>
+    /// Returns result of running <paramref name="onSome"/> if it is <c>Some</c>, otherwise returns result of running <paramref name="onNone"/>
+    /// </summary>
+    /// <param name="onSome">The function to run if <paramref name="input"/> is <c>Some</c></param>
+    /// <param name="onNone">The function to run if <paramref name="input"/> is <c>None</c></param>
+    /// <param name="input">The input option.</param>
+    /// <returns>
+    /// The result of running <paramref name="onSome"/> if the input is <c>Some</c>, else returns result of running <paramref name="onNone"/>.
+    /// </returns>
+    let inline either
+        ([<InlineIfLambda>] onSome: 'input -> Job<'output>)
+        (onNone: Job<'output>)
+        (input: Job<'input option>)
+        : Job<'output> =
+        input
+        |> Job.bind (
+            function
+            | Some v -> onSome v
+            | None -> onNone
+        )

src/FsToolkit.ErrorHandling.TaskResult/TaskOption.fs

@@ -30,3 +30,25 @@ module TaskOption =
     let inline zip x1 x2 =
         Task.zip x1 x2
         |> Task.map (fun (r1, r2) -> Option.zip r1 r2)
+
+
+    /// <summary>
+    /// Returns result of running <paramref name="onSome"/> if it is <c>Some</c>, otherwise returns result of running <paramref name="onNone"/>
+    /// </summary>
+    /// <param name="onSome">The function to run if <paramref name="input"/> is <c>Some</c></param>
+    /// <param name="onNone">The function to run if <paramref name="input"/> is <c>None</c></param>
+    /// <param name="input">The input option.</param>
+    /// <returns>
+    /// The result of running <paramref name="onSome"/> if the input is <c>Some</c>, else returns result of running <paramref name="onNone"/>.
+    /// </returns>
+    let inline either
+        ([<InlineIfLambda>] onSome: 'input -> Task<'output>)
+        ([<InlineIfLambda>] onNone: unit -> Task<'output>)
+        (input: Task<'input option>)
+        : Task<'output> =
+        input
+        |> Task.bind (
+            function
+            | Some v -> onSome v
+            | None -> onNone ()
+        )

src/FsToolkit.ErrorHandling/AsyncOption.fs

@@ -31,3 +31,24 @@ module AsyncOption =
         (input: Async<'input option>)
         : Async<'output option> =
         bind (fun f' -> bind (fun x' -> retn (f' x')) input) applier
+
+    /// <summary>
+    /// Returns result of running <paramref name="onSome"/> if it is <c>Some</c>, otherwise returns result of running <paramref name="onNone"/>
+    /// </summary>
+    /// <param name="onSome">The function to run if <paramref name="input"/> is <c>Some</c></param>
+    /// <param name="onNone">The function to run if <paramref name="input"/> is <c>None</c></param>
+    /// <param name="input">The input option.</param>
+    /// <returns>
+    /// The result of running <paramref name="onSome"/> if the input is <c>Some</c>, else returns result of running <paramref name="onNone"/>.
+    /// </returns>
+    let inline either
+        ([<InlineIfLambda>] onSome: 'input -> Async<'output>)
+        (onNone: Async<'output>)
+        (input: Async<'input option>)
+        : Async<'output> =
+        input
+        |> Async.bind (
+            function
+            | Some v -> onSome v
+            | None -> onNone
+        )

src/FsToolkit.ErrorHandling/Option.fs

@@ -130,6 +130,7 @@ module Option =
     /// <returns>
     /// The result of running <paramref name="onSome"/> if the input is <c>Some</c>, else returns result of running <paramref name="onNone"/>.
     /// </returns>
+    [<System.Obsolete("Call Option.either instead.", true)>]
     let inline maybe
         ([<InlineIfLambda>] onNone: unit -> 'output)
         ([<InlineIfLambda>] onSome: 'a -> 'output)
@@ -138,3 +139,21 @@ module Option =
         match input with
         | Some x -> onSome x
         | None -> onNone ()
+
+    /// <summary>
+    /// Returns result of running <paramref name="onSome"/> if it is <c>Some</c>, otherwise returns result of running <paramref name="onNone"/>
+    /// </summary>
+    /// <param name="onSome">The function to run if <paramref name="input"/> is <c>Some</c></param>
+    /// <param name="onNone">The function to run if <paramref name="input"/> is <c>None</c></param>
+    /// <param name="input">The input option.</param>
+    /// <returns>
+    /// The result of running <paramref name="onSome"/> if the input is <c>Some</c>, else returns result of running <paramref name="onNone"/>.
+    /// </returns>
+    let inline either
+        ([<InlineIfLambda>] onSome: 'a -> 'output)
+        ([<InlineIfLambda>] onNone: unit -> 'output)
+        (input: 'a option)
+        : 'output =
+        match input with
+        | Some x -> onSome x
+        | None -> onNone ()

src/FsToolkit.ErrorHandling/ValueOption.fs

@@ -124,4 +124,23 @@ module ValueOption =
             |> ofNull
         | ValueNone -> ValueNone
 
+
+    /// <summary>
+    /// Returns result of running <paramref name="onSome"/> if it is <c>ValueSome</c>, otherwise returns result of running <paramref name="onNone"/>
+    /// </summary>
+    /// <param name="onSome">The function to run if <paramref name="input"/> is <c>ValueSome</c></param>
+    /// <param name="onNone">The function to run if <paramref name="input"/> is <c>ValueNone</c></param>
+    /// <param name="input">The input option.</param>
+    /// <returns>
+    /// The result of running <paramref name="onSome"/> if the input is <c>ValueSome</c>, else returns result of running <paramref name="onNone"/>.
+    /// </returns>
+    let inline either
+        ([<InlineIfLambda>] onSome: 'a -> 'output)
+        ([<InlineIfLambda>] onNone: unit -> 'output)
+        (input: 'a voption)
+        : 'output =
+        match input with
+        | ValueSome x -> onSome x
+        | ValueNone -> onNone ()
+
 #endif

tests/FsToolkit.ErrorHandling.JobResult.Tests/JobOption.fs

@@ -118,6 +118,27 @@ let jobOptionOperatorTests =
             |> Expect.hasJobSomeValue (PostId newPostId)
     ]
 
+
+let eitherTests =
+    testList "JobOption.either Tests" [
+        testCaseJob "Some"
+        <| job {
+            let value1 = JobOption.retn 5
+            let f = job.Return 42
+            let add2 x = job { return x + 2 }
+            let! result = (JobOption.either add2 f value1)
+            Expect.equal result 7 ""
+        }
+        testCaseJob "None"
+        <| job {
+            let value1 = job.Return None
+            let f = job.Return 42
+            let add2 x = job { return x + 2 }
+            let! result = (JobOption.either add2 f value1)
+            Expect.equal result 42 ""
+        }
+    ]
+
 let allTests =
     testList "Job Option Tests" [
         mapTests

tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskOption.fs

@@ -127,11 +127,33 @@ let taskOptionOperatorTests =
             |> Expect.hasTaskSomeValue (PostId newPostId)
     ]
 
+
+let eitherTests =
+    testList "TaskOption.either Tests" [
+        testCaseTask "Some"
+        <| fun () -> task {
+            let value1 = TaskOption.retn 5
+            let f () = Task.FromResult 42
+            let add2 x = task { return x + 2 }
+            let! result = (TaskOption.either add2 f value1)
+            Expect.equal result 7 ""
+           }
+        testCaseTask "None"
+        <| fun () -> task {
+            let value1 = Task.FromResult None
+            let f () = Task.FromResult 42
+            let add2 x = task { return x + 2 }
+            let! result = (TaskOption.either add2 f value1)
+            Expect.equal result 42 ""
+           }
+    ]
+
 let allTests =
     testList "Task Option Tests" [
         mapTests
         bindTests
         applyTests
         retnTests
         taskOptionOperatorTests
+        eitherTests
     ]

tests/FsToolkit.ErrorHandling.Tests/AsyncOption.fs

@@ -103,11 +103,32 @@ let asyncOptionOperatorTests =
         }
     ]
 
+let eitherTests =
+    testList "AsyncOption.either Tests" [
+        testCaseAsync "Some"
+        <| async {
+            let value1 = AsyncOption.retn 5
+            let f = async.Return 42
+            let add2 x = async { return x + 2 }
+            let! result = (AsyncOption.either add2 f value1)
+            Expect.equal result 7 ""
+        }
+        testCaseAsync "None"
+        <| async {
+            let value1 = async.Return None
+            let f = async.Return 42
+            let add2 x = async { return x + 2 }
+            let! result = (AsyncOption.either add2 f value1)
+            Expect.equal result 42 ""
+        }
+    ]
+
 let allTests =
     testList "Async Option Tests" [
         mapTests
         bindTests
         applyTests
         retnTests
         asyncOptionOperatorTests
+        eitherTests
     ]

tests/FsToolkit.ErrorHandling.Tests/Option.fs

@@ -111,20 +111,20 @@ let bindNullTests =
             Expect.equal (Option.bindNull someBinder value1) (None) ""
     ]
 
-let maybeTests =
-    testList "Option.maybe Tests" [
+let eitherTests =
+    testList "Option.either Tests" [
         testCase "Some"
         <| fun _ ->
             let value1 = Some 5
             let f () = 42
             let add2 = (+) 2
-            Expect.equal (Option.maybe f add2 value1) 7 ""
+            Expect.equal (Option.either add2 f value1) 7 ""
         testCase "None"
         <| fun _ ->
             let value1 = None
             let f () = 42
             let add2 = (+) 2
-            Expect.equal (Option.maybe f add2 value1) 42 ""
+            Expect.equal (Option.either add2 f value1) 42 ""
     ]
 
 let allTests =
@@ -135,5 +135,5 @@ let allTests =
         ofResultTests
         ofNullTests
         bindNullTests
-        maybeTests
+        eitherTests
     ]

tests/FsToolkit.ErrorHandling.Tests/ValueOption.fs

@@ -114,6 +114,23 @@ let bindNullTests =
             Expect.equal (ValueOption.bindNull someBinder value1) (ValueNone) ""
     ]
 
+
+let eitherTests =
+    testList "ValueOption.either Tests" [
+        testCase "Some"
+        <| fun _ ->
+            let value1 = ValueSome 5
+            let f () = 42
+            let add2 = (+) 2
+            Expect.equal (ValueOption.either add2 f value1) 7 ""
+        testCase "None"
+        <| fun _ ->
+            let value1 = ValueNone
+            let f () = 42
+            let add2 = (+) 2
+            Expect.equal (ValueOption.either add2 f value1) 42 ""
+    ]
+
 let allTests =
     testList "ValueOption Tests" [
         traverseResultTests
@@ -122,6 +139,7 @@ let allTests =
         ofResultTests
         ofNullTests
         bindNullTests
+        eitherTests
     ]
 #else