Add explicit type parameters to ignore functions

Author: cmeeren

src/FsToolkit.ErrorHandling.JobResult/JobResult.fs

@@ -97,7 +97,7 @@ module JobResult =
         result |> Job.bind (Result.either ok ifErrorFunc)
 
     /// Replaces the wrapped value with unit
-    let inline ignore jr = jr |> map ignore
+    let inline ignore<'ok, 'error> (jr: Job<Result<'ok, 'error>>) = jr |> map ignore<'ok>
 
     /// Returns the specified error if the job-wrapped value is false.
     let inline requireTrue error value =
@@ -166,7 +166,7 @@ module JobResult =
 
     /// Same as defaultValue for a result where the Ok value is unit. The name
     /// describes better what is actually happening in this case.
-    let inline ignoreError jobResult = defaultValue () jobResult
+    let inline ignoreError<'error> (jobResult: Job<Result<unit, 'error>>) = defaultValue () jobResult
 
     /// If the job-wrapped result is Ok, executes the function on the Ok value.
     /// Passes through the input value.

src/FsToolkit.ErrorHandling.JobResult/JobResultOption.fs

@@ -24,4 +24,4 @@ module JobResultOption =
     let apply fJRO xJRO = map2 (fun f x -> f x) fJRO xJRO
 
     /// Replaces the wrapped value with unit
-    let inline ignore jro = jro |> map ignore
+    let inline ignore<'a, 'b> (jro: Job<Result<'a option, 'b>>) = jro |> map ignore<'a>

src/FsToolkit.ErrorHandling.TaskResult/TaskResult.fs

@@ -88,7 +88,7 @@ module TaskResult =
         result |> Task.bind (Result.either ok ifErrorFunc)
 
     /// Replaces the wrapped value with unit
-    let inline ignore tr = tr |> map ignore
+    let inline ignore<'ok, 'error> (tr: Task<Result<'ok, 'error>>) = tr |> map ignore<'ok>
 
     /// Returns the specified error if the task-wrapped value is false.
     let inline requireTrue error value =
@@ -158,7 +158,7 @@ module TaskResult =
 
     /// Same as defaultValue for a result where the Ok value is unit. The name
     /// describes better what is actually happening in this case.
-    let inline ignoreError taskResult = defaultValue () taskResult
+    let inline ignoreError<'error> (taskResult: Task<Result<unit, 'error>>) = defaultValue () taskResult
 
     /// If the task-wrapped result is Ok, executes the function on the Ok value.
     /// Passes through the input value.

src/FsToolkit.ErrorHandling.TaskResult/TaskResultOption.fs

@@ -1,5 +1,7 @@
 namespace FsToolkit.ErrorHandling
 
+open System.Threading.Tasks
+
 
 [<RequireQualifiedAccess>]
 module TaskResultOption =
@@ -24,4 +26,4 @@ module TaskResultOption =
     let inline apply fTRO xTRO = map2 (fun f x -> f x) fTRO xTRO
 
     /// Replaces the wrapped value with unit
-    let inline ignore tro = tro |> map ignore
+    let inline ignore<'ok, 'error> (tro: Task<Result<'ok option, 'error>>) = tro |> map ignore<'ok>

src/FsToolkit.ErrorHandling/AsyncResult.fs

@@ -132,7 +132,7 @@ module AsyncResult =
         Async.bind (Result.either ok ifErrorFunc) input
 
     /// Replaces the wrapped value with unit
-    let inline ignore (value: Async<Result<'ok, 'error>>) : Async<Result<unit, 'error>> = value |> map ignore
+    let inline ignore<'ok, 'error> (value: Async<Result<'ok, 'error>>) : Async<Result<unit, 'error>> = value |> map ignore<'ok>
 
     /// Returns the specified error if the async-wrapped value is false.
     let inline requireTrue (error: 'error) (value: Async<bool>) : Async<Result<unit, 'error>> =
@@ -212,7 +212,7 @@ module AsyncResult =
 
     /// Same as defaultValue for a result where the Ok value is unit. The name
     /// describes better what is actually happening in this case.
-    let inline ignoreError (result: Async<Result<unit, 'error>>) : Async<unit> = defaultValue () result
+    let inline ignoreError<'error> (result: Async<Result<unit, 'error>>) : Async<unit> = defaultValue () result
 
     /// If the async-wrapped result is Ok, executes the function on the Ok value.
     /// Passes through the input value.

src/FsToolkit.ErrorHandling/AsyncResultOption.fs

@@ -45,4 +45,4 @@ module AsyncResultOption =
         map2 (fun f x -> f x) applier input
 
     /// Replaces the wrapped value with unit
-    let ignore (value: Async<Result<'ok option, 'error>>) : Async<Result<unit option, 'error>> = value |> map ignore
+    let ignore<'ok, 'error> (value: Async<Result<'ok option, 'error>>) : Async<Result<unit option, 'error>> = value |> map ignore<'ok>

src/FsToolkit.ErrorHandling/Result.fs

@@ -160,7 +160,7 @@ module Result =
         | Error e -> ifErrorFunc e
 
     /// Replaces the wrapped value with unit
-    let inline ignore (result: Result<'ok, 'error>) : Result<unit, 'error> =
+    let inline ignore<'ok, 'error> (result: Result<'ok, 'error>) : Result<unit, 'error> =
         match result with
         | Ok _ -> Ok()
         | Error e -> Error e
@@ -256,7 +256,7 @@ module Result =
 
     /// Same as defaultValue for a result where the Ok value is unit. The name
     /// describes better what is actually happening in this case.
-    let inline ignoreError (result: Result<unit, 'error>) : unit = defaultValue () result
+    let inline ignoreError<'error> (result: Result<unit, 'error>) : unit = defaultValue () result
 
     /// If the result is Ok and the predicate returns true, executes the function
     /// on the Ok value. Passes through the input value.

src/FsToolkit.ErrorHandling/ResultOption.fs

@@ -23,4 +23,4 @@ module ResultOption =
     let map3 f x y z = apply (map2 f x y) z
 
     /// Replaces the wrapped value with unit
-    let ignore ro = ro |> map ignore
+    let ignore<'ok, 'error> (ro: Result<'ok option, 'error>) = ro |> map ignore<'ok>

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

@@ -228,7 +228,15 @@ let ignoreTests =
           <| fun _ ->
               createPostFailure validCreatePostRequest
               |> JobResult.ignore
-              |> Expect.hasJobErrorValueSync commonEx ]
+              |> Expect.hasJobErrorValueSync commonEx
+
+          testCase "can call ignore without type parameters"
+          <| fun _ ->
+              ignore JobResult.ignore
+
+          testCase "can call ignore with type parameters"
+          <| fun _ ->
+              ignore<Job<Result<int, string>> -> Job<Result<unit, string>>> JobResult.ignore<int, string> ]
 
 let err = "foobar"
 let toJob = Job.singleton
@@ -469,7 +477,13 @@ let ignoreErrorTests =
           <| fun _ -> Expect.hasJobValue () (JobResult.ignoreError (toJob (Ok())))
 
           testCase "ignoreError returns the unit for Error"
-          <| fun _ -> Expect.hasJobValue () (JobResult.ignoreError (toJob (Error err))) ]
+          <| fun _ -> Expect.hasJobValue () (JobResult.ignoreError (toJob (Error err)))
+
+          testCase "Can call ignoreError without type parameter"
+          <| fun _ -> ignore JobResult.ignoreError
+
+          testCase "Can call ignoreError with type parameter"
+          <| fun _ -> ignore<Job<Result<unit, string>> -> Job<unit>> JobResult.ignoreError<string> ]
 
 [<Tests>]
 let teeTests =

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

@@ -161,7 +161,13 @@ let ignoreTests =
           <| fun _ ->
               getUserById (UserId(Guid.Empty))
               |> JobResultOption.ignore
-              |> Expect.hasJobErrorValueSync "invalid user id" ]
+              |> Expect.hasJobErrorValueSync "invalid user id"
+
+          testCase "can call ignore without type parameters"
+          <| fun _ -> ignore JobResultOption.ignore
+
+          testCase "can call ignore with type parameters"
+          <| fun _ -> ignore<Job<Result<int option, string>> -> Job<Result<unit option, string>>> JobResultOption.ignore<int, string> ]
 
 [<Tests>]
 let computationExpressionTests =