Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Improve stack traces within CEs #81

Merged
merged 2 commits into from
May 25, 2020
Merged

Improve stack traces within CEs #81

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4427d06
better stack traces for asyncresult
May 25, 2020
4f7becf
Inline more bind/returnfrom
May 25, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
120 changes: 60 additions & 60 deletions src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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>> =
Expand All @@ -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)
Expand Down Expand Up @@ -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)



Expand All @@ -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 {
Expand All @@ -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()
Loading