add requireSomeWith

gitbook/result/requireFunctions.md

@@ -66,7 +66,7 @@ let result : Result<unit, string> =
 
 ## requireSome
 
-Converts an Option to a Result, using the given error if None.
+Converts an Option to a Result, using the given function to supply an error if None.
 
 ### Function Signature
 
@@ -96,6 +96,38 @@ let result : Result<unit, string> =
 // Error "Value must be Some"
 ```
 
+## requireSomeWith
+
+Converts an Option to a Result, using the given function to supply an error if None.
+
+### Function Signature
+
+```fsharp
+'a -> 'b option -> Result<'b, 'a>
+```
+
+### Examples
+
+#### Example 1
+
+```fsharp
+let result : Result<unit, string> =
+    Some 1
+    |> Result.requireSomeWith (fun () -> "Value must be Some")
+
+// Ok ()
+```
+
+#### Example 2
+
+```fsharp
+let result : Result<unit, string> =
+    None
+    |> Result.requireSomeWith (fun () -> "Value must be Some")
+
+// Error "Value must be Some"
+```
+
 ## requireNone
 
 Converts an Option to a Result, using the given error if Some.

src/FsToolkit.ErrorHandling.JobResult/JobResult.fs

@@ -1,4 +1,4 @@
-namespace FsToolkit.ErrorHandling
+namespace FsToolkit.ErrorHandling
 
 open Hopac
 open Hopac.Infixes
@@ -124,6 +124,10 @@ module JobResult =
         option
         |> Job.map (Result.requireSome error)
 
+    let inline requireSomeWith ifErrorThunk option =
+        option
+        |> Job.map (Result.requireSomeWith ifErrorThunk)
+
     // Converts an job-wrapped Option to a Result, using the given error if Some.
     let inline requireNone error option =
         option

src/FsToolkit.ErrorHandling/AsyncResult.fs

@@ -157,6 +157,13 @@ module AsyncResult =
         value
         |> Async.map (Result.requireSome error)
 
+    let inline requireSomeWith
+        (ifErrorThunk: unit -> 'error)
+        (value: Async<'ok option>)
+        : Async<Result<'ok, 'error>> =
+        value
+        |> Async.map (Result.requireSomeWith ifErrorThunk)
+
     // Converts an async-wrapped Option to a Result, using the given error if Some.
     let inline requireNone
         (error: 'error)

src/FsToolkit.ErrorHandling/Result.fs

@@ -307,6 +307,22 @@ module Result =
         | Some x -> Ok x
         | None -> Error error
 
+    /// <summary>
+    /// Returns the contained value if <c>Some</c>, otherwise evaluates <param name="ifErrorThunk"/> and returns the value.
+    ///
+    /// Documentation is found here: <href>https://demystifyfp.gitbook.io/fstoolkit-errorhandling/fstoolkit.errorhandling/result/others#requireSomeWith</href>
+    /// </summary>
+    /// <param name="ifErrorThunk">The function to evaluate if the result is <c>None</c>.</param>
+    /// <param name="option">The input option.</param>
+    /// <returns>The contained value if <c>Some</c>, otherwise the result of evaluating <paramref name="ifErrorThunk"/>.</returns>
+    let inline requireSomeWith
+        (ifErrorThunk: unit -> 'error)
+        (option: 'ok option)
+        : Result<'ok, 'error> =
+        match option with
+        | Some x -> Ok x
+        | None -> Error(ifErrorThunk ())
+
     /// <summary>
     /// Requires a value to be <c>None</c>, otherwise returns an error result.
     ///

src/FsToolkit.ErrorHandling/TaskResult.fs

@@ -109,6 +109,10 @@ module TaskResult =
         option
         |> Task.map (Result.requireSome error)
 
+    let inline requireSomeWith ifErrorThunk option =
+        option
+        |> Task.map (Result.requireSomeWith ifErrorThunk)
+
     // Converts an task-wrapped Option to a Result, using the given error if Some.
     let inline requireNone error option =
         option

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

@@ -284,6 +284,22 @@ let requireSomeTests =
             |> Expect.hasJobErrorValueSync err
     ]
 
+[<Tests>]
+let requireSomeWithTests =
+    testList "JobResult.requireSomeWith Tests" [
+        testCase "requireSomeWith happy path"
+        <| fun _ ->
+            toJob (Some 42)
+            |> JobResult.requireSomeWith (fun () -> err)
+            |> Expect.hasJobOkValueSync 42
+
+        testCase "requireSomeWith error path"
+        <| fun _ ->
+            toJob None
+            |> JobResult.requireSomeWith (fun () -> err)
+            |> Expect.hasJobErrorValueSync err
+    ]
+
 [<Tests>]
 let requireNoneTests =
     testList "JobResult.requireNone Tests" [

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

@@ -289,6 +289,22 @@ let requireSomeTests =
             |> Expect.hasTaskErrorValueSync err
     ]
 
+[<Tests>]
+let requireSomeWithTests =
+    testList "TaskResult.requireSomeWith Tests" [
+        testCase "requireSomeWith happy path"
+        <| fun _ ->
+            toTask (Some 42)
+            |> TaskResult.requireSomeWith (fun () -> err)
+            |> Expect.hasTaskOkValueSync 42
+
+        testCase "requireSomeWith error path"
+        <| fun _ ->
+            toTask None
+            |> TaskResult.requireSomeWith (fun () -> err)
+            |> Expect.hasTaskErrorValueSync err
+    ]
+
 [<Tests>]
 let requireNoneTests =
     testList "TaskResult.requireNone Tests" [

tests/FsToolkit.ErrorHandling.Tests/AsyncResult.fs

@@ -298,6 +298,18 @@ let requireSomeTests =
             |> Expect.hasAsyncErrorValue err)
     ]
 
+let requireSomeWithTests =
+    testList "AsyncResult.requireSomeWith Tests" [
+        testCaseAsync "requireSomeWith happy path"
+        <| (toAsync (Some 42)
+            |> AsyncResult.requireSomeWith (fun () -> err)
+            |> Expect.hasAsyncOkValue 42)
+
+        testCaseAsync "requireSomeWith error path"
+        <| (toAsync None
+            |> AsyncResult.requireSomeWith (fun () -> err)
+            |> Expect.hasAsyncErrorValue err)
+    ]
 
 let requireNoneTests =
     testList "AsyncResult.requireNone Tests" [
@@ -1006,6 +1018,7 @@ let allTests =
         requireTrueTests
         requireFalseTests
         requireSomeTests
+        requireSomeWithTests
         requireNoneTests
         requireValueSomeTests
         requireValueNoneTests

tests/FsToolkit.ErrorHandling.Tests/Result.fs

@@ -332,6 +332,19 @@ let requireSomeTests =
             |> Expect.hasErrorValue err
     ]
 
+let requireSomeWithTests =
+    testList "requireSomeWith Tests" [
+        testCase "requireSomeWith happy path"
+        <| fun _ ->
+            Result.requireSomeWith (fun () -> err) (Some 42)
+            |> Expect.hasOkValue 42
+
+        testCase "requireSomeWith error path"
+        <| fun _ ->
+            Result.requireSomeWith (fun () -> err) None
+            |> Expect.hasErrorValue err
+    ]
+
 let requireNotNullTests =
     testList "requireNotNull Tests" [
         testCase "requireNotNull happy path"
@@ -914,6 +927,7 @@ let allTests =
         requireTrueTests
         requireFalseTests
         requireSomeTests
+        requireSomeWithTests
         requireNoneTests
         requireValueSomeTests
         requireValueNoneTests