Inline more bind/returnfrom

demystifyfp · May 25, 2020 · aab4818 · aab4818
1 parent 00fcbc2
commit aab4818
Show file tree

Hide file tree

Showing 7 changed files with 161 additions and 203 deletions.
diff --git a/src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs b/src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs
@@ -12,32 +12,32 @@ module JobResultCE =
     member __.Return (value: 'T) : Job<Result<'T, 'TError>> =
       job.Return <| result.Return value
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (asyncResult: Async<Result<'T, 'TError>>)
         : Job<Result<'T, 'TError>> =
       asyncResult |> Job.fromAsync
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (jobResult: Job<Result<'T, 'TError>>)
         : Job<Result<'T, 'TError>> =
       jobResult
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (taskResult: Task<Result<'T, 'TError>>)
         : Job<Result<'T, 'TError>> =
       Job.awaitTask taskResult
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (taskResult: unit -> Task<Result<'T, 'TError>>)
         : Job<Result<'T, 'TError>> =
       Job.fromTask taskResult
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (result: Result<'T, 'TError>)
         : Job<Result<'T, 'TError>> =
       job.Return result
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (result: Choice<'T, 'TError>)
         : Job<Result<'T, 'TError>> =
       result
@@ -47,7 +47,7 @@ module JobResultCE =
     member __.Zero () : Job<Result<unit, 'TError>> =
       job.Return <| result.Zero ()
 
-    member __.Bind
+    member inline __.Bind
         (jobResult: Job<Result<'T, 'TError>>,
          binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
@@ -57,30 +57,30 @@ module JobResultCE =
         | Ok x -> return! binder x
         | Error x -> return Error x
       }
-    member this.Bind
+    member inline this.Bind
         (asyncResult: Async<Result<'T, 'TError>>,
          binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.fromAsync asyncResult, binder)
 
-    member this.Bind
+    member inline this.Bind
         (taskResult: Task<Result<'T, 'TError>>,
          binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.awaitTask taskResult, binder)
 
-    member this.Bind
+    member inline this.Bind
         (taskResult: unit -> Task<Result<'T, 'TError>>,
          binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.fromTask taskResult, binder)
 
-    member this.Bind
+    member inline this.Bind
         (result: Result<'T, 'TError>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(this.ReturnFrom result, binder)
 
-    member this.Bind
+    member inline this.Bind
         (result: Choice<'T, 'TError>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(this.ReturnFrom result, binder)
@@ -141,17 +141,17 @@ module JobResultCE =
 
 
 
-    member __.BindReturn(x: Job<Result<'T,'U>>, f) = JobResult.map f x
-    member __.BindReturn(x: Async<Result<'T,'U>>, f) = __.BindReturn(x |> Job.fromAsync, f)
-    member __.BindReturn(x: Async<Choice<'T,'U>>, f) = __.BindReturn(x |> Async.map Result.ofChoice, f)
-    member __.BindReturn(x: Result<'T,'U>, f) = __.BindReturn(x |> Job.singleton, f) 
-    member __.BindReturn(x: Choice<'T,'U>, f) = __.BindReturn(x |> Result.ofChoice |> Job.singleton, f) 
-    member __.BindReturn(x: Task<Result<'T,'U>>, f) = __.BindReturn(x |> Job.awaitTask, f) 
+    member inline __.BindReturn(x: Job<Result<'T,'U>>, f) = JobResult.map f x
+    member inline __.BindReturn(x: Async<Result<'T,'U>>, f) = __.BindReturn(x |> Job.fromAsync, f)
+    member inline __.BindReturn(x: Async<Choice<'T,'U>>, f) = __.BindReturn(x |> Async.map Result.ofChoice, f)
+    member inline __.BindReturn(x: Result<'T,'U>, f) = __.BindReturn(x |> Job.singleton, f) 
+    member inline __.BindReturn(x: Choice<'T,'U>, f) = __.BindReturn(x |> Result.ofChoice |> Job.singleton, f) 
+    member inline __.BindReturn(x: Task<Result<'T,'U>>, f) = __.BindReturn(x |> Job.awaitTask, f) 
 
 
-    member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip t1 t2
-    member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (Job.awaitTask t1) (Job.awaitTask t2)
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (Job.fromAsync t1) (Job.fromAsync t2)
+    member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip t1 t2
+    member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (Job.awaitTask t1) (Job.awaitTask t2)
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (Job.fromAsync t1) (Job.fromAsync t2)
 
 
 
@@ -162,37 +162,37 @@ module JobResultCEExtensions =
   // overload resolution between Job<_> and Job<Result<_,_>>.
   type JobResultBuilder with
 
-    member __.ReturnFrom (job': Job<'T>) : Job<Result<'T, 'TError>> =
+    member inline __.ReturnFrom (job': Job<'T>) : Job<Result<'T, 'TError>> =
       job {
         let! x = job'
         return Ok x
       }
 
-    member __.ReturnFrom (async': Async<'T>) : Job<Result<'T, 'TError>> =
+    member inline __.ReturnFrom (async': Async<'T>) : Job<Result<'T, 'TError>> =
       job {
         let! x = async' |> Job.fromAsync
         return Ok x
       }
 
-    member __.ReturnFrom (task: Task<'T>) : Job<Result<'T, 'TError>> =
+    member inline __.ReturnFrom (task: Task<'T>) : Job<Result<'T, 'TError>> =
       job {
         let! x = task
         return Ok x
       }   
 
-    member __.ReturnFrom (task: unit -> Task<'T>) : Job<Result<'T, 'TError>> =
+    member inline __.ReturnFrom (task: unit -> Task<'T>) : Job<Result<'T, 'TError>> =
       job {
         let! x = task |> Job.fromTask
         return Ok x
       }
 
-    member __.ReturnFrom (task: Task) : Job<Result<unit, 'TError>> =
+    member inline __.ReturnFrom (task: Task) : Job<Result<unit, 'TError>> =
       job {
         do! Job.awaitUnitTask task
         return result.Zero ()
       }
 
-    member this.Bind
+    member inline this.Bind
         (job': Job<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       let jResult = job {
@@ -201,81 +201,81 @@ module JobResultCEExtensions =
       }
       this.Bind(jResult, binder)
 
-    member this.Bind
+    member inline this.Bind
         (task: Async<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.fromAsync task, binder)
 
-    member this.Bind
+    member inline this.Bind
         (task: Task<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.awaitTask task, binder)
 
-    member this.Bind
+    member inline this.Bind
         (task: unit -> Task<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
         : Job<Result<'U, 'TError>> =
       this.Bind(Job.fromTask task, binder)
 
-    member this.Bind
+    member inline this.Bind
         (task: Task, binder: unit -> Job<Result<'T, 'TError>>)
         : Job<Result<'T, 'TError>> =
       this.Bind(Job.awaitUnitTask task, binder)
 
-    member __.BindReturn(x: Job<'T>, f) = 
+    member inline __.BindReturn(x: Job<'T>, f) = 
       __.BindReturn(x |> Job.map Result.Ok, f)
-    member __.BindReturn(x: Async<'T>, f) = 
+    member inline __.BindReturn(x: Async<'T>, f) = 
       __.BindReturn(x |> Async.map Result.Ok, f)
-    member __.BindReturn(x: Task<'T>, f) = 
+    member inline __.BindReturn(x: Task<'T>, f) = 
       __.BindReturn(x |> Task.map Result.Ok, f)
-    member __.BindReturn(x: Task, f) = 
+    member inline __.BindReturn(x: Task, f) = 
       __.BindReturn(x |> Task.ofUnit |> Task.map Result.Ok, f)
 
 
 
-    member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) =  JobResult.zip (t1) (t2 |> Job.fromAsync) 
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.fromAsync) (t2) 
+    member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) =  JobResult.zip (t1) (t2 |> Job.fromAsync) 
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.fromAsync) (t2) 
 
 
-    member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) =  JobResult.zip (t1) (t2 |> Job.awaitTask) 
-    member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.awaitTask) (t2) 
+    member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) =  JobResult.zip (t1) (t2 |> Job.awaitTask) 
+    member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.awaitTask) (t2) 
 
-    member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2) |> Job.fromAsync
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1) (t2 |> Async.AwaitTask) |> Job.fromAsync
+    member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2) |> Job.fromAsync
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1) (t2 |> Async.AwaitTask) |> Job.fromAsync
 
-    member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2  |> Async.singleton) |> Job.fromAsync
-    member __.MergeSources(t1: Result<'T,'U>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.AwaitTask) |> Job.fromAsync
+    member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2  |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Result<'T,'U>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.AwaitTask) |> Job.fromAsync
 
 
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<'T1>) = AsyncResult.zip t1 (t2  |> Async.map Result.Ok) |> Job.fromAsync
-    member __.MergeSources(t1: Async<'T>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.map Result.Ok) t2 |> Job.fromAsync
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<'T1>) = AsyncResult.zip t1 (t2  |> Async.map Result.Ok) |> Job.fromAsync
+    member inline __.MergeSources(t1: Async<'T>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.map Result.Ok) t2 |> Job.fromAsync
 
-    member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Result<'T1,'U>) = JobResult.zip t1 (t2  |> Job.singleton) 
-    member __.MergeSources(t1: Result<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.singleton) t2 
-    member __.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync 
+    member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Result<'T1,'U>) = JobResult.zip t1 (t2  |> Job.singleton) 
+    member inline __.MergeSources(t1: Result<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.singleton) t2 
+    member inline __.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync 
 
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip t1 (t2  |> Async.singleton) |> Job.fromAsync
-    member __.MergeSources(t1: Result<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) t2 |> Job.fromAsync
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip t1 (t2  |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Result<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) t2 |> Job.fromAsync
 
 
-    member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Choice<'T1,'U>) = AsyncResult.zip t1 (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
-    member __.MergeSources(t1: Choice<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) t2 |> Job.fromAsync
+    member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Choice<'T1,'U>) = AsyncResult.zip t1 (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Choice<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) t2 |> Job.fromAsync
 
-    member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Choice<'T1,'U>) = JobResult.zip t1 (t2 |> Result.ofChoice |> Job.singleton) 
-    member __.MergeSources(t1: Choice<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Result.ofChoice |> Job.singleton) t2 
-    member __.MergeSources(t1: Choice<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Choice<'T1,'U>) = JobResult.zip t1 (t2 |> Result.ofChoice |> Job.singleton) 
+    member inline __.MergeSources(t1: Choice<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Result.ofChoice |> Job.singleton) t2 
+    member inline __.MergeSources(t1: Choice<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
 
-    member __.MergeSources(t1: Choice<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
-    member __.MergeSources(t1: Result<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Choice<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
+    member inline __.MergeSources(t1: Result<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
 
 
 [<AutoOpen>]
 module JobResultCEExtensions2 =
   // Having Async<_> members as extensions gives them lower priority in
   // overload resolution between Async<_> and Async<Result<_,_>>.
   type JobResultBuilder with
-    member __.MergeSources(t1: Job<'T>, t2: Job<'T1>) = JobResult.zip (t1 |> Job.map Result.Ok) (t2 |> Job.map Result.Ok)
-    member __.MergeSources(t1: Async<'T>, t2: Async<'T1>) = AsyncResult.zip (t1 |> Async.map Result.Ok) (t2 |> Async.map Result.Ok) |> Job.fromAsync
-    member __.MergeSources(t1: Task<'T>, t2: Task<'T1>) = TaskResult.zip (t1 |> Task.map Result.Ok) (t2 |> Task.map Result.Ok) |> Job.awaitTask
+    member inline __.MergeSources(t1: Job<'T>, t2: Job<'T1>) = JobResult.zip (t1 |> Job.map Result.Ok) (t2 |> Job.map Result.Ok)
+    member inline __.MergeSources(t1: Async<'T>, t2: Async<'T1>) = AsyncResult.zip (t1 |> Async.map Result.Ok) (t2 |> Async.map Result.Ok) |> Job.fromAsync
+    member inline __.MergeSources(t1: Task<'T>, t2: Task<'T1>) = TaskResult.zip (t1 |> Task.map Result.Ok) (t2 |> Task.map Result.Ok) |> Job.awaitTask
 
 
   let jobResult = JobResultBuilder()