Skip to content

Commit aab4818

Browse files
Jimmy ByrdTheAngryByrd
Jimmy Byrd
authored and
TheAngryByrd
committed
Inline more bind/returnfrom
1 parent 00fcbc2 commit aab4818

File tree

7 files changed

+161
-203
lines changed

7 files changed

+161
-203
lines changed

‎src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs‎

Lines changed: 60 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -12,32 +12,32 @@ module JobResultCE =
1212
member __.Return (value: 'T) : Job<Result<'T, 'TError>> =
1313
job.Return <| result.Return value
1414

15-
member __.ReturnFrom
15+
member inline __.ReturnFrom
1616
(asyncResult: Async<Result<'T, 'TError>>)
1717
: Job<Result<'T, 'TError>> =
1818
asyncResult |> Job.fromAsync
1919

20-
member __.ReturnFrom
20+
member inline __.ReturnFrom
2121
(jobResult: Job<Result<'T, 'TError>>)
2222
: Job<Result<'T, 'TError>> =
2323
jobResult
2424

25-
member __.ReturnFrom
25+
member inline __.ReturnFrom
2626
(taskResult: Task<Result<'T, 'TError>>)
2727
: Job<Result<'T, 'TError>> =
2828
Job.awaitTask taskResult
2929

30-
member __.ReturnFrom
30+
member inline __.ReturnFrom
3131
(taskResult: unit -> Task<Result<'T, 'TError>>)
3232
: Job<Result<'T, 'TError>> =
3333
Job.fromTask taskResult
3434

35-
member __.ReturnFrom
35+
member inline __.ReturnFrom
3636
(result: Result<'T, 'TError>)
3737
: Job<Result<'T, 'TError>> =
3838
job.Return result
3939

40-
member __.ReturnFrom
40+
member inline __.ReturnFrom
4141
(result: Choice<'T, 'TError>)
4242
: Job<Result<'T, 'TError>> =
4343
result
@@ -47,7 +47,7 @@ module JobResultCE =
4747
member __.Zero () : Job<Result<unit, 'TError>> =
4848
job.Return <| result.Zero ()
4949

50-
member __.Bind
50+
member inline __.Bind
5151
(jobResult: Job<Result<'T, 'TError>>,
5252
binder: 'T -> Job<Result<'U, 'TError>>)
5353
: Job<Result<'U, 'TError>> =
@@ -57,30 +57,30 @@ module JobResultCE =
5757
| Ok x -> return! binder x
5858
| Error x -> return Error x
5959
}
60-
member this.Bind
60+
member inline this.Bind
6161
(asyncResult: Async<Result<'T, 'TError>>,
6262
binder: 'T -> Job<Result<'U, 'TError>>)
6363
: Job<Result<'U, 'TError>> =
6464
this.Bind(Job.fromAsync asyncResult, binder)
6565

66-
member this.Bind
66+
member inline this.Bind
6767
(taskResult: Task<Result<'T, 'TError>>,
6868
binder: 'T -> Job<Result<'U, 'TError>>)
6969
: Job<Result<'U, 'TError>> =
7070
this.Bind(Job.awaitTask taskResult, binder)
7171

72-
member this.Bind
72+
member inline this.Bind
7373
(taskResult: unit -> Task<Result<'T, 'TError>>,
7474
binder: 'T -> Job<Result<'U, 'TError>>)
7575
: Job<Result<'U, 'TError>> =
7676
this.Bind(Job.fromTask taskResult, binder)
7777

78-
member this.Bind
78+
member inline this.Bind
7979
(result: Result<'T, 'TError>, binder: 'T -> Job<Result<'U, 'TError>>)
8080
: Job<Result<'U, 'TError>> =
8181
this.Bind(this.ReturnFrom result, binder)
8282

83-
member this.Bind
83+
member inline this.Bind
8484
(result: Choice<'T, 'TError>, binder: 'T -> Job<Result<'U, 'TError>>)
8585
: Job<Result<'U, 'TError>> =
8686
this.Bind(this.ReturnFrom result, binder)
@@ -141,17 +141,17 @@ module JobResultCE =
141141

142142

143143

144-
member __.BindReturn(x: Job<Result<'T,'U>>, f) = JobResult.map f x
145-
member __.BindReturn(x: Async<Result<'T,'U>>, f) = __.BindReturn(x |> Job.fromAsync, f)
146-
member __.BindReturn(x: Async<Choice<'T,'U>>, f) = __.BindReturn(x |> Async.map Result.ofChoice, f)
147-
member __.BindReturn(x: Result<'T,'U>, f) = __.BindReturn(x |> Job.singleton, f)
148-
member __.BindReturn(x: Choice<'T,'U>, f) = __.BindReturn(x |> Result.ofChoice |> Job.singleton, f)
149-
member __.BindReturn(x: Task<Result<'T,'U>>, f) = __.BindReturn(x |> Job.awaitTask, f)
144+
member inline __.BindReturn(x: Job<Result<'T,'U>>, f) = JobResult.map f x
145+
member inline __.BindReturn(x: Async<Result<'T,'U>>, f) = __.BindReturn(x |> Job.fromAsync, f)
146+
member inline __.BindReturn(x: Async<Choice<'T,'U>>, f) = __.BindReturn(x |> Async.map Result.ofChoice, f)
147+
member inline __.BindReturn(x: Result<'T,'U>, f) = __.BindReturn(x |> Job.singleton, f)
148+
member inline __.BindReturn(x: Choice<'T,'U>, f) = __.BindReturn(x |> Result.ofChoice |> Job.singleton, f)
149+
member inline __.BindReturn(x: Task<Result<'T,'U>>, f) = __.BindReturn(x |> Job.awaitTask, f)
150150

151151

152-
member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip t1 t2
153-
member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (Job.awaitTask t1) (Job.awaitTask t2)
154-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (Job.fromAsync t1) (Job.fromAsync t2)
152+
member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip t1 t2
153+
member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (Job.awaitTask t1) (Job.awaitTask t2)
154+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (Job.fromAsync t1) (Job.fromAsync t2)
155155

156156

157157

@@ -162,37 +162,37 @@ module JobResultCEExtensions =
162162
// overload resolution between Job<_> and Job<Result<_,_>>.
163163
type JobResultBuilder with
164164

165-
member __.ReturnFrom (job': Job<'T>) : Job<Result<'T, 'TError>> =
165+
member inline __.ReturnFrom (job': Job<'T>) : Job<Result<'T, 'TError>> =
166166
job {
167167
let! x = job'
168168
return Ok x
169169
}
170170

171-
member __.ReturnFrom (async': Async<'T>) : Job<Result<'T, 'TError>> =
171+
member inline __.ReturnFrom (async': Async<'T>) : Job<Result<'T, 'TError>> =
172172
job {
173173
let! x = async' |> Job.fromAsync
174174
return Ok x
175175
}
176176

177-
member __.ReturnFrom (task: Task<'T>) : Job<Result<'T, 'TError>> =
177+
member inline __.ReturnFrom (task: Task<'T>) : Job<Result<'T, 'TError>> =
178178
job {
179179
let! x = task
180180
return Ok x
181181
}
182182

183-
member __.ReturnFrom (task: unit -> Task<'T>) : Job<Result<'T, 'TError>> =
183+
member inline __.ReturnFrom (task: unit -> Task<'T>) : Job<Result<'T, 'TError>> =
184184
job {
185185
let! x = task |> Job.fromTask
186186
return Ok x
187187
}
188188

189-
member __.ReturnFrom (task: Task) : Job<Result<unit, 'TError>> =
189+
member inline __.ReturnFrom (task: Task) : Job<Result<unit, 'TError>> =
190190
job {
191191
do! Job.awaitUnitTask task
192192
return result.Zero ()
193193
}
194194

195-
member this.Bind
195+
member inline this.Bind
196196
(job': Job<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
197197
: Job<Result<'U, 'TError>> =
198198
let jResult = job {
@@ -201,81 +201,81 @@ module JobResultCEExtensions =
201201
}
202202
this.Bind(jResult, binder)
203203

204-
member this.Bind
204+
member inline this.Bind
205205
(task: Async<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
206206
: Job<Result<'U, 'TError>> =
207207
this.Bind(Job.fromAsync task, binder)
208208

209-
member this.Bind
209+
member inline this.Bind
210210
(task: Task<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
211211
: Job<Result<'U, 'TError>> =
212212
this.Bind(Job.awaitTask task, binder)
213213

214-
member this.Bind
214+
member inline this.Bind
215215
(task: unit -> Task<'T>, binder: 'T -> Job<Result<'U, 'TError>>)
216216
: Job<Result<'U, 'TError>> =
217217
this.Bind(Job.fromTask task, binder)
218218

219-
member this.Bind
219+
member inline this.Bind
220220
(task: Task, binder: unit -> Job<Result<'T, 'TError>>)
221221
: Job<Result<'T, 'TError>> =
222222
this.Bind(Job.awaitUnitTask task, binder)
223223

224-
member __.BindReturn(x: Job<'T>, f) =
224+
member inline __.BindReturn(x: Job<'T>, f) =
225225
__.BindReturn(x |> Job.map Result.Ok, f)
226-
member __.BindReturn(x: Async<'T>, f) =
226+
member inline __.BindReturn(x: Async<'T>, f) =
227227
__.BindReturn(x |> Async.map Result.Ok, f)
228-
member __.BindReturn(x: Task<'T>, f) =
228+
member inline __.BindReturn(x: Task<'T>, f) =
229229
__.BindReturn(x |> Task.map Result.Ok, f)
230-
member __.BindReturn(x: Task, f) =
230+
member inline __.BindReturn(x: Task, f) =
231231
__.BindReturn(x |> Task.ofUnit |> Task.map Result.Ok, f)
232232

233233

234234

235-
member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (t1) (t2 |> Job.fromAsync)
236-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.fromAsync) (t2)
235+
member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = JobResult.zip (t1) (t2 |> Job.fromAsync)
236+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.fromAsync) (t2)
237237

238238

239-
member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (t1) (t2 |> Job.awaitTask)
240-
member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.awaitTask) (t2)
239+
member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = JobResult.zip (t1) (t2 |> Job.awaitTask)
240+
member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.awaitTask) (t2)
241241

242-
member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2) |> Job.fromAsync
243-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1) (t2 |> Async.AwaitTask) |> Job.fromAsync
242+
member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2) |> Job.fromAsync
243+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1) (t2 |> Async.AwaitTask) |> Job.fromAsync
244244

245-
member __.MergeSources(t1: Task<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2 |> Async.singleton) |> Job.fromAsync
246-
member __.MergeSources(t1: Result<'T,'U>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.AwaitTask) |> Job.fromAsync
245+
member inline __.MergeSources(t1: Task<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.AwaitTask) (t2 |> Async.singleton) |> Job.fromAsync
246+
member inline __.MergeSources(t1: Result<'T,'U>, t2: Task<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.AwaitTask) |> Job.fromAsync
247247

248248

249-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<'T1>) = AsyncResult.zip t1 (t2 |> Async.map Result.Ok) |> Job.fromAsync
250-
member __.MergeSources(t1: Async<'T>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.map Result.Ok) t2 |> Job.fromAsync
249+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Async<'T1>) = AsyncResult.zip t1 (t2 |> Async.map Result.Ok) |> Job.fromAsync
250+
member inline __.MergeSources(t1: Async<'T>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.map Result.Ok) t2 |> Job.fromAsync
251251

252-
member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Result<'T1,'U>) = JobResult.zip t1 (t2 |> Job.singleton)
253-
member __.MergeSources(t1: Result<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.singleton) t2
254-
member __.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
252+
member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Result<'T1,'U>) = JobResult.zip t1 (t2 |> Job.singleton)
253+
member inline __.MergeSources(t1: Result<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Job.singleton) t2
254+
member inline __.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
255255

256-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip t1 (t2 |> Async.singleton) |> Job.fromAsync
257-
member __.MergeSources(t1: Result<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) t2 |> Job.fromAsync
256+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Result<'T1,'U>) = AsyncResult.zip t1 (t2 |> Async.singleton) |> Job.fromAsync
257+
member inline __.MergeSources(t1: Result<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Async.singleton) t2 |> Job.fromAsync
258258

259259

260-
member __.MergeSources(t1: Async<Result<'T,'U>>, t2: Choice<'T1,'U>) = AsyncResult.zip t1 (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
261-
member __.MergeSources(t1: Choice<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) t2 |> Job.fromAsync
260+
member inline __.MergeSources(t1: Async<Result<'T,'U>>, t2: Choice<'T1,'U>) = AsyncResult.zip t1 (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
261+
member inline __.MergeSources(t1: Choice<'T,'U>, t2: Async<Result<'T1,'U>>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) t2 |> Job.fromAsync
262262

263-
member __.MergeSources(t1: Job<Result<'T,'U>>, t2: Choice<'T1,'U>) = JobResult.zip t1 (t2 |> Result.ofChoice |> Job.singleton)
264-
member __.MergeSources(t1: Choice<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Result.ofChoice |> Job.singleton) t2
265-
member __.MergeSources(t1: Choice<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
263+
member inline __.MergeSources(t1: Job<Result<'T,'U>>, t2: Choice<'T1,'U>) = JobResult.zip t1 (t2 |> Result.ofChoice |> Job.singleton)
264+
member inline __.MergeSources(t1: Choice<'T,'U>, t2: Job<Result<'T1,'U>>) = JobResult.zip (t1 |> Result.ofChoice |> Job.singleton) t2
265+
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
266266

267-
member __.MergeSources(t1: Choice<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
268-
member __.MergeSources(t1: Result<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
267+
member inline __.MergeSources(t1: Choice<'T,'U>, t2: Result<'T1,'U>) = AsyncResult.zip (t1 |> Result.ofChoice |> Async.singleton) (t2 |> Async.singleton) |> Job.fromAsync
268+
member inline __.MergeSources(t1: Result<'T,'U>, t2: Choice<'T1,'U>) = AsyncResult.zip (t1 |> Async.singleton) (t2 |> Result.ofChoice |> Async.singleton) |> Job.fromAsync
269269

270270

271271
[<AutoOpen>]
272272
module JobResultCEExtensions2 =
273273
// Having Async<_> members as extensions gives them lower priority in
274274
// overload resolution between Async<_> and Async<Result<_,_>>.
275275
type JobResultBuilder with
276-
member __.MergeSources(t1: Job<'T>, t2: Job<'T1>) = JobResult.zip (t1 |> Job.map Result.Ok) (t2 |> Job.map Result.Ok)
277-
member __.MergeSources(t1: Async<'T>, t2: Async<'T1>) = AsyncResult.zip (t1 |> Async.map Result.Ok) (t2 |> Async.map Result.Ok) |> Job.fromAsync
278-
member __.MergeSources(t1: Task<'T>, t2: Task<'T1>) = TaskResult.zip (t1 |> Task.map Result.Ok) (t2 |> Task.map Result.Ok) |> Job.awaitTask
276+
member inline __.MergeSources(t1: Job<'T>, t2: Job<'T1>) = JobResult.zip (t1 |> Job.map Result.Ok) (t2 |> Job.map Result.Ok)
277+
member inline __.MergeSources(t1: Async<'T>, t2: Async<'T1>) = AsyncResult.zip (t1 |> Async.map Result.Ok) (t2 |> Async.map Result.Ok) |> Job.fromAsync
278+
member inline __.MergeSources(t1: Task<'T>, t2: Task<'T1>) = TaskResult.zip (t1 |> Task.map Result.Ok) (t2 |> Task.map Result.Ok) |> Job.awaitTask
279279

280280

281281
let jobResult = JobResultBuilder()

0 commit comments

Comments
 (0)