Formatting

Author: TheAngryByrd

src/FsToolkit.ErrorHandling.AsyncSeq/Library.fs

@@ -29,7 +29,8 @@ module AsyncSeqCE =
                                     | Some (Ok x) -> return! whileAsync x
                                     | Some (Error e) -> return Error e
                                     | None -> return! this.Zero()
-                                })
+                                }
+                                )
                             )
 
                     return! whileAsync x
@@ -45,11 +46,17 @@ module AsyncSeqCE =
             ) : Async<Result<unit, 'TError>> =
             this.Using(xs.GetEnumerator(), (fun enum -> this.While(enum.MoveNext, binder)))
 
-        member this.For(xs: AsyncSeq<'T>, binder: 'T -> Async<Result<unit, 'TError>>) : Async<Result<unit, 'TError>> =
+        member this.For
+            (
+                xs: AsyncSeq<'T>,
+                binder: 'T -> Async<Result<unit, 'TError>>
+            ) : Async<Result<unit, 'TError>> =
             this.Using(
                 xs.GetEnumerator(),
                 fun enum ->
-                    let moveNext = enum.MoveNext >> Async.map (Option.map Ok)
+                    let moveNext =
+                        enum.MoveNext
+                        >> Async.map (Option.map Ok)
 
                     this.While(moveNext, binder)
             )

src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskResultCE.fs

@@ -9,19 +9,28 @@ module JobOptionCE =
 
     type JobOptionBuilder() =
 
-        member inline _.Return(value: 'T) : Job<_ option> = job.Return <| option.Return value
+        member inline _.Return(value: 'T) : Job<_ option> =
+            job.Return
+            <| option.Return value
 
         member inline _.ReturnFrom(jobResult: Job<_ option>) : Job<_ option> = jobResult
 
-        member inline _.Zero() : Job<_ option> = job.Return <| option.Zero()
+        member inline _.Zero() : Job<_ option> =
+            job.Return
+            <| option.Zero()
 
-        member inline _.Bind(jobResult: Job<_ option>, [<InlineIfLambda>] binder: 'T -> Job<_ option>) : Job<_ option> = job {
-            let! result = jobResult
+        member inline _.Bind
+            (
+                jobResult: Job<_ option>,
+                [<InlineIfLambda>] binder: 'T -> Job<_ option>
+            ) : Job<_ option> =
+            job {
+                let! result = jobResult
 
-            match result with
-            | Some x -> return! binder x
-            | None -> return None
-        }
+                match result with
+                | Some x -> return! binder x
+                | None -> return None
+            }
 
         member inline this.Bind
             (
@@ -30,9 +39,14 @@ module JobOptionCE =
             ) : Job<_ option> =
             this.Bind(Job.fromTask taskResult, binder)
 
-        member inline _.Delay([<InlineIfLambda>] generator: unit -> Job<_ option>) : Job<_ option> = Job.delay generator
+        member inline _.Delay([<InlineIfLambda>] generator: unit -> Job<_ option>) : Job<_ option> =
+            Job.delay generator
 
-        member inline this.Combine(computation1: Job<_ option>, computation2: Job<_ option>) : Job<_ option> =
+        member inline this.Combine
+            (
+                computation1: Job<_ option>,
+                computation2: Job<_ option>
+            ) : Job<_ option> =
             this.Bind(computation1, (fun () -> computation2))
 
         member inline _.TryWith
@@ -71,12 +85,19 @@ module JobOptionCE =
             job.Using(resource, binder)
 
         member this.While(guard: unit -> bool, computation: Job<_ option>) : Job<_ option> =
-            if not <| guard () then
+            if
+                not
+                <| guard ()
+            then
                 this.Zero()
             else
                 this.Bind(computation, (fun () -> this.While(guard, computation)))
 
-        member inline this.For(sequence: #seq<'T>, [<InlineIfLambda>] binder: 'T -> Job<_ option>) : Job<_ option> =
+        member inline this.For
+            (
+                sequence: #seq<'T>,
+                [<InlineIfLambda>] binder: 'T -> Job<_ option>
+            ) : Job<_ option> =
             this.Using(
                 sequence.GetEnumerator(),
                 fun enum -> this.While(enum.MoveNext, this.Delay(fun () -> binder enum.Current))
@@ -92,12 +113,16 @@ module JobOptionCE =
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(async: Async<_ option>) : Job<_ option> = async |> Job.fromAsync
+        member inline _.Source(async: Async<_ option>) : Job<_ option> =
+            async
+            |> Job.fromAsync
 
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(task: Task<_ option>) : Job<_ option> = task |> Job.awaitTask
+        member inline _.Source(task: Task<_ option>) : Job<_ option> =
+            task
+            |> Job.awaitTask
 
     let jobOption = JobOptionBuilder()
 
@@ -121,14 +146,22 @@ module JobOptionCEExtensions =
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(a: Job<'t>) = a |> Job.map Some
+        member inline _.Source(a: Job<'t>) =
+            a
+            |> Job.map Some
 
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(a: Async<'t>) = a |> Job.fromAsync |> Job.map Some
+        member inline _.Source(a: Async<'t>) =
+            a
+            |> Job.fromAsync
+            |> Job.map Some
 
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(a: Task<'t>) = a |> Job.awaitTask |> Job.map Some
+        member inline _.Source(a: Task<'t>) =
+            a
+            |> Job.awaitTask
+            |> Job.map Some

src/FsToolkit.ErrorHandling.JobResult/JobOptionCE.fs

@@ -11,25 +11,43 @@ module JobResult =
     let inline mapError ([<InlineIfLambda>] f) jr = Job.map (Result.mapError f) jr
 
     let inline bind ([<InlineIfLambda>] f: 'a -> Job<Result<'c, 'b>>) (jr: Job<Result<'a, 'b>>) =
-        Job.bind (Result.either f (Error >> Job.result)) jr
+        Job.bind
+            (Result.either
+                f
+                (Error
+                 >> Job.result))
+            jr
 
     let inline foldResult ([<InlineIfLambda>] onSuccess) ([<InlineIfLambda>] onError) jr =
         Job.map (Result.fold onSuccess onError) jr
 
     let inline ofAsync aAsync =
-        aAsync |> Job.fromAsync |> Job.catch |> Job.map Result.ofChoice
+        aAsync
+        |> Job.fromAsync
+        |> Job.catch
+        |> Job.map Result.ofChoice
 
     let inline fromTask aTask =
-        aTask |> Job.fromTask |> Job.catch |> Job.map Result.ofChoice
+        aTask
+        |> Job.fromTask
+        |> Job.catch
+        |> Job.map Result.ofChoice
 
     let inline fromUnitTask aTask =
-        aTask |> Job.fromUnitTask |> Job.catch |> Job.map Result.ofChoice
+        aTask
+        |> Job.fromUnitTask
+        |> Job.catch
+        |> Job.map Result.ofChoice
 
-    let inline retn x = Ok x |> Job.result
+    let inline retn x =
+        Ok x
+        |> Job.result
 
     let inline ok x = retn x
 
-    let inline returnError x = Error x |> Job.result
+    let inline returnError x =
+        Error x
+        |> Job.result
 
     let inline error x = returnError x
 
@@ -59,7 +77,8 @@ module JobResult =
     /// 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))
+        result
+        |> Job.bind (Result.either ok (fun _ -> ifError))
 
     /// <summary>
     /// Returns <paramref name="result"/> if it is <c>Ok</c>, otherwise executes <paramref name="ifErrorFunc"/> and returns the result.
@@ -84,115 +103,146 @@ module JobResult =
         ([<InlineIfLambda>] ifErrorFunc: 'error -> Job<Result<'ok, 'error2>>)
         (result: Job<Result<'ok, 'error>>)
         =
-        result |> Job.bind (Result.either ok ifErrorFunc)
+        result
+        |> Job.bind (Result.either ok ifErrorFunc)
 
     /// Replaces the wrapped value with unit
-    let inline ignore<'ok, 'error> (jr: Job<Result<'ok, 'error>>) = jr |> map ignore<'ok>
+    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 =
-        value |> Job.map (Result.requireTrue error)
+        value
+        |> Job.map (Result.requireTrue error)
 
     /// Returns the specified error if the job-wrapped value is true.
     let inline requireFalse error value =
-        value |> Job.map (Result.requireFalse error)
+        value
+        |> Job.map (Result.requireFalse error)
 
     // Converts an job-wrapped Option to a Result, using the given error if None.
     let inline requireSome error option =
-        option |> Job.map (Result.requireSome error)
+        option
+        |> Job.map (Result.requireSome error)
 
     // Converts an job-wrapped Option to a Result, using the given error if Some.
     let inline requireNone error option =
-        option |> Job.map (Result.requireNone error)
+        option
+        |> Job.map (Result.requireNone error)
 
     /// Returns Ok if the job-wrapped value and the provided value are equal, or the specified error if not.
     let inline requireEqual x1 x2 error =
-        x2 |> Job.map (fun x2' -> Result.requireEqual x1 x2' error)
+        x2
+        |> Job.map (fun x2' -> Result.requireEqual x1 x2' error)
 
     /// Returns Ok if the two values are equal, or the specified error if not.
     let inline requireEqualTo other error this =
-        this |> Job.map (Result.requireEqualTo other error)
+        this
+        |> Job.map (Result.requireEqualTo other error)
 
     /// Returns Ok if the job-wrapped sequence is empty, or the specified error if not.
     let inline requireEmpty error xs =
-        xs |> Job.map (Result.requireEmpty error)
+        xs
+        |> Job.map (Result.requireEmpty error)
 
     /// Returns Ok if the job-wrapped sequence is not-empty, or the specified error if not.
     let inline requireNotEmpty error xs =
-        xs |> Job.map (Result.requireNotEmpty error)
+        xs
+        |> Job.map (Result.requireNotEmpty error)
 
     /// Returns the first item of the job-wrapped sequence if it exists, or the specified
     /// error if the sequence is empty
     let inline requireHead error xs =
-        xs |> Job.map (Result.requireHead error)
+        xs
+        |> Job.map (Result.requireHead error)
 
     /// Replaces an error value of an job-wrapped result with a custom error
     /// value.
     let inline setError error jobResult =
-        jobResult |> Job.map (Result.setError error)
+        jobResult
+        |> Job.map (Result.setError error)
 
     /// Replaces a unit error value of an job-wrapped result with a custom
     /// error value. Safer than setError since you're not losing any information.
     let inline withError error jobResult =
-        jobResult |> Job.map (Result.withError error)
+        jobResult
+        |> Job.map (Result.withError error)
 
     /// Extracts the contained value of an job-wrapped result if Ok, otherwise
     /// uses ifError.
     let inline defaultValue ifError jobResult =
-        jobResult |> Job.map (Result.defaultValue ifError)
+        jobResult
+        |> Job.map (Result.defaultValue ifError)
 
     /// Extracts the contained value of an job-wrapped result if Error, otherwise
     /// uses ifOk.
     let inline defaultError ifOk jobResult =
-        jobResult |> Job.map (Result.defaultError ifOk)
+        jobResult
+        |> Job.map (Result.defaultError ifOk)
 
     /// Extracts the contained value of an job-wrapped result if Ok, otherwise
     /// evaluates ifErrorThunk and uses the result.
     let inline defaultWith ifErrorThunk jobResult =
-        jobResult |> Job.map (Result.defaultWith ifErrorThunk)
+        jobResult
+        |> Job.map (Result.defaultWith ifErrorThunk)
 
     /// 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<'error> (jobResult: Job<Result<unit, 'error>>) = 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.
-    let inline tee ([<InlineIfLambda>] f) jobResult = jobResult |> Job.map (Result.tee f)
+    let inline tee ([<InlineIfLambda>] f) jobResult =
+        jobResult
+        |> Job.map (Result.tee f)
 
     /// If the job-wrapped result is Ok and the predicate returns true, executes
     /// the function on the Ok value. Passes through the input value.
     let inline teeIf ([<InlineIfLambda>] predicate) ([<InlineIfLambda>] f) jobResult =
-        jobResult |> Job.map (Result.teeIf predicate f)
+        jobResult
+        |> Job.map (Result.teeIf predicate f)
 
     /// If the job-wrapped result is Error, executes the function on the Error
     /// value. Passes through the input value.
     let inline teeError ([<InlineIfLambda>] f) jobResult =
-        jobResult |> Job.map (Result.teeError f)
+        jobResult
+        |> Job.map (Result.teeError f)
 
     /// If the job-wrapped result is Error and the predicate returns true,
     /// executes the function on the Error value. Passes through the input value.
     let inline teeErrorIf ([<InlineIfLambda>] predicate) ([<InlineIfLambda>] f) jobResult =
-        jobResult |> Job.map (Result.teeErrorIf predicate f)
+        jobResult
+        |> Job.map (Result.teeErrorIf predicate f)
 
     /// Takes two results and returns a tuple of the pair
     let inline zip j1 j2 =
-        Job.zip j1 j2 |> Job.map (fun (r1, r2) -> Result.zip r1 r2)
+        Job.zip j1 j2
+        |> Job.map (fun (r1, r2) -> Result.zip r1 r2)
 
     /// Takes two results and returns a tuple of the error pair
     let inline zipError j1 j2 =
-        Job.zip j1 j2 |> Job.map (fun (r1, r2) -> Result.zipError r1 r2)
+        Job.zip j1 j2
+        |> Job.map (fun (r1, r2) -> Result.zipError r1 r2)
 
     /// Catches exceptions and maps them to the Error case using the provided function.
     let inline catch f x =
         x
         |> Job.catch
-        |> Job.map (function
+        |> Job.map (
+            function
             | Choice1Of2 (Ok v) -> Ok v
             | Choice1Of2 (Error err) -> Error err
-            | Choice2Of2 ex -> Error(f ex))
+            | Choice2Of2 ex -> Error(f ex)
+        )
 
     /// Lift Job to JobResult
-    let inline ofJob x = x |> Job.map Ok
+    let inline ofJob x =
+        x
+        |> Job.map Ok
 
     /// Lift Result to JobResult
-    let inline ofResult (x: Result<_, _>) = x |> Job.singleton
+    let inline ofResult (x: Result<_, _>) =
+        x
+        |> Job.singleton