Converted all uses of retn, ok, and some into singleton

Author: 1eyewonder

src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskValidationCE.fs

@@ -323,12 +323,6 @@ module CancellableTaskValidation =
         let x = Result.mapError List.singleton result
         fun _ -> Task.FromResult(x)
 
-    /// <summary>Lifts an item to a CancellableTaskValidation.</summary>
-    /// <param name="item">The item to be the ok result of the CancellableTaskValidation.</param>
-    /// <returns>A CancellableTaskValidation with the item as the result.</returns>
-    let inline ok (item: 'ok) : CancellableTaskValidation<'ok, 'error> =
-        fun _ -> Task.FromResult(Ok item)
-
     /// <summary>Lifts an item to a CancellableTaskValidation.</summary>
     /// <param name="error">The item to be the error result of the CancellableTaskValidation.</param>
     /// <returns>A CancellableTaskValidation with the item as the result.</returns>
@@ -338,11 +332,9 @@ module CancellableTaskValidation =
 
     let inline ofChoice (choice: Choice<'ok, 'error>) : CancellableTaskValidation<'ok, 'error> =
         match choice with
-        | Choice1Of2 x -> ok x
+        | Choice1Of2 x -> singleton x
         | Choice2Of2 x -> error x
 
-    let inline retn (value: 'ok) : CancellableTaskValidation<'ok, 'error> = ok value
-
 
     let inline mapError
         ([<InlineIfLambda>] errorMapper: 'errorInput -> 'errorOutput)
@@ -480,7 +472,7 @@ module CancellableTaskValidation =
 
             return!
                 result
-                |> Result.either ok (fun _ -> ifError)
+                |> Result.either singleton (fun _ -> ifError)
         }
 
     let inline orElseWith
@@ -493,7 +485,7 @@ module CancellableTaskValidation =
 
             return!
                 match result with
-                | Ok x -> ok x
+                | Ok x -> singleton x
                 | Error err -> ifErrorFunc err
         }
 
@@ -928,7 +920,7 @@ module CTVMergeSourcesExtensionsTV1CV2 =
             (
                 left: 'Awaiter1,
                 [<InlineIfLambda>] right: CancellationToken -> 'Awaiter2
-            )  =
+            ) =
             this.Source(
                 // cancellableTask.Run(
                 //     cancellableTask.Bind(
@@ -950,17 +942,17 @@ module CTVMergeSourcesExtensionsTV1CV2 =
                     let! struct (l1, r1) = cancellableTask.MergeSources(left, right)
                     return Validation.zip l1 r1
                 }
-                // fun ct -> Awaitable.GetTaskAwaiter(IcedTasks.Polyfill.Task.Tasks.TaskBuilder.task {
-                //     let r1 = right ct
-                //     let l1 = left
-                //     let! struct (l1, r1) = IcedTasks.Polyfill.Task.Tasks.TaskBuilder.task.MergeSources(l1, r1)
+            // fun ct -> Awaitable.GetTaskAwaiter(IcedTasks.Polyfill.Task.Tasks.TaskBuilder.task {
+            //     let r1 = right ct
+            //     let l1 = left
+            //     let! struct (l1, r1) = IcedTasks.Polyfill.Task.Tasks.TaskBuilder.task.MergeSources(l1, r1)
 
-                //     // let foo  = cancellableTask.MergeSources(left, right) ct
-                //     return Validation.zip l1 r1
-                // })
-                // |> ignore
+            //     // let foo  = cancellableTask.MergeSources(left, right) ct
+            //     return Validation.zip l1 r1
+            // })
+            // |> ignore
 
-                // Unchecked.defaultof<_>
+            // Unchecked.defaultof<_>
             )
 
 

src/FsToolkit.ErrorHandling.JobResult/JobOption.fs

@@ -20,10 +20,10 @@ module JobOption =
             return! t
         }
 
-    let inline retn x = job { return Some x }
+    let inline singleton x = job { return Some x }
 
     let inline apply f x =
-        bind (fun f' -> bind (fun x' -> retn (f' x')) x) f
+        bind (fun f' -> bind (fun x' -> singleton (f' x')) x) f
 
 
     /// <summary>

src/FsToolkit.ErrorHandling.JobResult/JobResult.fs

@@ -39,12 +39,10 @@ module JobResult =
         |> Job.catch
         |> Job.map Result.ofChoice
 
-    let inline retn x =
+    let inline singleton x =
         Ok x
         |> Job.result
 
-    let inline ok x = retn x
-
     let inline returnError x =
         Error x
         |> Job.result
@@ -68,17 +66,17 @@ module JobResult =
     /// <example>
     /// <code>
     ///     JobResult.error "First" |> JobResult.orElse (JobResult.error "Second") // evaluates to Error ("Second")
-    ///     JobResult.error "First" |> JobResult.orElse (JobResult.ok "Second") // evaluates to Ok ("Second")
-    ///     JobResult.ok "First" |> JobResult.orElse (JobResult.error "Second") // evaluates to Ok ("First")
-    ///     JobResult.ok "First" |> JobResult.orElse (JobResult.ok "Second") // evaluates to Ok ("First")
+    ///     JobResult.error "First" |> JobResult.orElse (JobResult.singleton "Second") // evaluates to Ok ("Second")
+    ///     JobResult.singleton "First" |> JobResult.orElse (JobResult.error "Second") // evaluates to Ok ("First")
+    ///     JobResult.singleton "First" |> JobResult.orElse (JobResult.singleton "Second") // evaluates to Ok ("First")
     /// </code>
     /// </example>
     /// <returns>
     /// The result if the result is Ok, else returns <paramref name="ifError"/>.
     /// </returns>
     let inline orElse (ifError: Job<Result<'ok, 'error2>>) (result: Job<Result<'ok, 'error>>) =
         result
-        |> Job.bind (Result.either ok (fun _ -> ifError))
+        |> Job.bind (Result.either singleton (fun _ -> ifError))
 
     /// <summary>
     /// Returns <paramref name="result"/> if it is <c>Ok</c>, otherwise executes <paramref name="ifErrorFunc"/> and returns the result.
@@ -91,9 +89,9 @@ module JobResult =
     /// <example>
     /// <code>
     ///     JobResult.error "First" |> JobResult.orElseWith (fun _ -> JobResult.error "Second") // evaluates to Error ("Second")
-    ///     JobResult.error "First" |> JobResult.orElseWith (fun _ -> JobResult.ok "Second") // evaluates to Ok ("Second")
-    ///     JobResult.ok "First" |> JobResult.orElseWith (fun _ -> JobResult.error "Second") // evaluates to Ok ("First")
-    ///     JobResult.ok "First" |> JobResult.orElseWith (fun _ -> JobResult.ok "Second") // evaluates to Ok ("First")
+    ///     JobResult.error "First" |> JobResult.orElseWith (fun _ -> JobResult.singleton "Second") // evaluates to Ok ("Second")
+    ///     JobResult.singleton "First" |> JobResult.orElseWith (fun _ -> JobResult.error "Second") // evaluates to Ok ("First")
+    ///     JobResult.singleton "First" |> JobResult.orElseWith (fun _ -> JobResult.singleton "Second") // evaluates to Ok ("First")
     /// </code>
     /// </example>
     /// <returns>
@@ -104,7 +102,7 @@ module JobResult =
         (result: Job<Result<'ok, 'error>>)
         =
         result
-        |> Job.bind (Result.either ok ifErrorFunc)
+        |> Job.bind (Result.either singleton ifErrorFunc)
 
     /// Replaces the wrapped value with unit
     let inline ignore<'ok, 'error> (jr: Job<Result<'ok, 'error>>) =

src/FsToolkit.ErrorHandling.JobResult/JobResultOption.fs

@@ -9,7 +9,7 @@ module JobResultOption =
         let binder opt =
             match opt with
             | Some x -> f x
-            | None -> JobResult.retn None
+            | None -> JobResult.singleton None
 
         JobResult.bind binder jro
 
@@ -19,7 +19,7 @@ module JobResultOption =
     let inline map3 ([<InlineIfLambda>] f) xJRO yJRO zJRO =
         JobResult.map3 (Option.map3 f) xJRO yJRO zJRO
 
-    let inline retn value =
+    let inline singleton value =
         Some value
         |> Ok
         |> Job.result

src/FsToolkit.ErrorHandling.JobResult/JobResultOptionCE.fs

@@ -5,7 +5,7 @@ module JobResultOptionCE =
     open Hopac
 
     type JobResultOptionBuilder() =
-        member inline _.Return value = JobResultOption.retn value
+        member inline _.Return value = JobResultOption.singleton value
         member inline _.ReturnFrom value = value
         member inline _.Bind(result, [<InlineIfLambda>] binder) = JobResultOption.bind binder result
 

src/FsToolkit.ErrorHandling.JobResult/List.fs

@@ -24,7 +24,7 @@ module List =
             }
 
     let traverseJobResultM f xs =
-        traverseJobResultM' (JobResult.retn []) f xs
+        traverseJobResultM' (JobResult.singleton []) f xs
 
     let sequenceJobResultM xs = traverseJobResultM id xs
 
@@ -40,7 +40,7 @@ module List =
                 let! fR = f x
 
                 match s, fR with
-                | Ok ys, Ok y -> return! traverseJobResultA' (JobResult.retn (y :: ys)) f xs
+                | Ok ys, Ok y -> return! traverseJobResultA' (JobResult.singleton (y :: ys)) f xs
                 | Error errs, Error e ->
                     return! traverseJobResultA' (JobResult.returnError (e :: errs)) f xs
                 | Ok _, Error e -> return! traverseJobResultA' (JobResult.returnError [ e ]) f xs
@@ -49,6 +49,6 @@ module List =
 
 
     let traverseJobResultA f xs =
-        traverseJobResultA' (JobResult.retn []) f xs
+        traverseJobResultA' (JobResult.singleton []) f xs
 
     let sequenceJobResultA xs = traverseJobResultA id xs

src/FsToolkit.ErrorHandling/Array.fs

@@ -53,7 +53,7 @@ module Array =
     let sequenceResultM xs = traverseResultM id xs
 
     let traverseAsyncResultM f xs =
-        traverseAsyncResultM' (AsyncResult.retn [||]) f xs
+        traverseAsyncResultM' (AsyncResult.singleton [||]) f xs
 
     let sequenceAsyncResultM xs = traverseAsyncResultM id xs
 
@@ -88,7 +88,8 @@ module Array =
 
                 match s, fR with
                 | Ok ys, Ok y ->
-                    return! traverseAsyncResultA' (AsyncResult.retn (Array.append [| y |] ys)) f xs
+                    return!
+                        traverseAsyncResultA' (AsyncResult.singleton (Array.append [| y |] ys)) f xs
                 | Error errs, Error e ->
                     return!
                         traverseAsyncResultA'
@@ -127,7 +128,7 @@ module Array =
     let sequenceValidationA xs = traverseValidationA id xs
 
     let traverseAsyncResultA f xs =
-        traverseAsyncResultA' (AsyncResult.retn [||]) f xs
+        traverseAsyncResultA' (AsyncResult.singleton [||]) f xs
 
     let sequenceAsyncResultA xs = traverseAsyncResultA id xs
 
@@ -193,7 +194,7 @@ module Array =
     let sequenceOptionM xs = traverseOptionM id xs
 
     let traverseAsyncOptionM f xs =
-        traverseAsyncOptionM' (AsyncOption.retn [||]) f xs
+        traverseAsyncOptionM' (AsyncOption.singleton [||]) f xs
 
     let sequenceAsyncOptionM xs = traverseAsyncOptionM id xs
 

src/FsToolkit.ErrorHandling/AsyncOption.fs

@@ -21,16 +21,13 @@ module AsyncOption =
             )
             input
 
-    let inline retn (value: 'value) : Async<'value option> = Async.singleton (Some value)
-
-
-    let inline some (value: 'value) : Async<'value option> = Async.singleton (Some value)
+    let inline singleton (value: 'value) : Async<'value option> = Async.singleton (Some value)
 
     let inline apply
         (applier: Async<('input -> 'output) option>)
         (input: Async<'input option>)
         : Async<'output option> =
-        bind (fun f' -> bind (fun x' -> retn (f' x')) input) applier
+        bind (fun f' -> bind (fun x' -> singleton (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"/>

src/FsToolkit.ErrorHandling/AsyncOptionCE.fs

@@ -7,7 +7,7 @@ open System
 module AsyncOptionCE =
     type AsyncOptionBuilder() =
 
-        member inline _.Return(value: 'value) : Async<'value option> = AsyncOption.retn value
+        member inline _.Return(value: 'value) : Async<'value option> = AsyncOption.singleton value
 
         member inline _.ReturnFrom(value: Async<'value option>) : Async<'value option> = value
 

src/FsToolkit.ErrorHandling/AsyncResult.fs

@@ -5,13 +5,10 @@ open System.Threading.Tasks
 [<RequireQualifiedAccess>]
 module AsyncResult =
 
-
-    let inline retn (value: 'ok) : Async<Result<'ok, 'error>> =
+    let inline singleton (value: 'ok) : Async<Result<'ok, 'error>> =
         Ok value
         |> Async.singleton
 
-    let inline ok (value: 'ok) : Async<Result<'ok, 'error>> = retn value
-
     let inline returnError (error: 'error) : Async<Result<'ok, 'error>> =
         Error error
         |> Async.singleton
@@ -99,9 +96,9 @@ module AsyncResult =
     /// <example>
     /// <code>
     ///     AsyncResult.error "First" |> AsyncResult.orElse (AsyncResult.error "Second") // evaluates to Error ("Second")
-    ///     AsyncResult.error "First" |> AsyncResult.orElse (AsyncResult.ok "Second") // evaluates to Ok ("Second")
-    ///     AsyncResult.ok "First" |> AsyncResult.orElse (AsyncResult.error "Second") // evaluates to Ok ("First")
-    ///     AsyncResult.ok "First" |> AsyncResult.orElse (AsyncResult.ok "Second") // evaluates to Ok ("First")
+    ///     AsyncResult.error "First" |> AsyncResult.orElse (AsyncResult.singleton "Second") // evaluates to Ok ("Second")
+    ///     AsyncResult.singleton "First" |> AsyncResult.orElse (AsyncResult.error "Second") // evaluates to Ok ("First")
+    ///     AsyncResult.singleton "First" |> AsyncResult.orElse (AsyncResult.singleton "Second") // evaluates to Ok ("First")
     /// </code>
     /// </example>
     /// <returns>
@@ -111,7 +108,7 @@ module AsyncResult =
         (ifError: Async<Result<'ok, 'errorOutput>>)
         (input: Async<Result<'ok, 'errorInput>>)
         : Async<Result<'ok, 'errorOutput>> =
-        Async.bind (Result.either ok (fun _ -> ifError)) input
+        Async.bind (Result.either singleton (fun _ -> ifError)) input
 
     /// <summary>
     /// Returns <paramref name="input"/> if it is <c>Ok</c>, otherwise executes <paramref name="ifErrorFunc"/> and returns the result.
@@ -124,9 +121,9 @@ module AsyncResult =
     /// <example>
     /// <code>
     ///     AsyncResult.error "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.error "Second") // evaluates to Error ("Second")
-    ///     AsyncResult.error "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.ok "Second") // evaluates to Ok ("Second")
-    ///     AsyncResult.ok "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.error "Second") // evaluates to Ok ("First")
-    ///     AsyncResult.ok "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.ok "Second") // evaluates to Ok ("First")
+    ///     AsyncResult.error "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.singleton "Second") // evaluates to Ok ("Second")
+    ///     AsyncResult.singleton "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.error "Second") // evaluates to Ok ("First")
+    ///     AsyncResult.singleton "First" |> AsyncResult.orElseWith (fun _ -> AsyncResult.singleton "Second") // evaluates to Ok ("First")
     /// </code>
     /// </example>
     /// <returns>
@@ -136,7 +133,7 @@ module AsyncResult =
         ([<InlineIfLambda>] ifErrorFunc: 'errorInput -> Async<Result<'ok, 'errorOutput>>)
         (input: Async<Result<'ok, 'errorInput>>)
         : Async<Result<'ok, 'errorOutput>> =
-        Async.bind (Result.either ok ifErrorFunc) input
+        Async.bind (Result.either singleton ifErrorFunc) input
 
     /// Replaces the wrapped value with unit
     let inline ignore<'ok, 'error>