better stack traces for asyncresult

Author: Jimmy Byrd

src/FsToolkit.ErrorHandling/Async.fs

@@ -3,15 +3,15 @@ namespace FsToolkit.ErrorHandling
 [<RequireQualifiedAccess>]
 module Async = 
 
-  let singleton value = value |> async.Return
+  let inline singleton value = value |> async.Return
 
-  let bind f x = async.Bind(x, f)
+  let inline bind f x = async.Bind(x, f)
 
   let apply f x =
     bind (fun f' ->
       bind (fun x' -> singleton(f' x')) x) f
 
-  let map f x = x |> bind (f >> singleton)
+  let inline map f x = x |> bind (f >> singleton)
 
   let map2 f x y =
     (apply (apply (singleton f) x) y)

src/FsToolkit.ErrorHandling/AsyncResult.fs

@@ -5,7 +5,7 @@ open System.Threading.Tasks
 [<RequireQualifiedAccess>]
 module AsyncResult = 
 
-  let map f ar =
+  let inline map f ar =
     Async.map (Result.map f) ar
 
   let mapError f ar =

src/FsToolkit.ErrorHandling/AsyncResultCE.fs

@@ -23,7 +23,7 @@ module AsyncResultCE =
       Async.AwaitTask taskResult
     #endif
 
-    member __.ReturnFrom
+    member inline __.ReturnFrom
         (result: Result<'T, 'TError>)
         : Async<Result<'T, 'TError>> =
       async.Return result
@@ -38,7 +38,7 @@ module AsyncResultCE =
     member __.Zero () : Async<Result<unit, 'TError>> =
       async.Return <| result.Zero ()
 
-    member __.Bind
+    member inline __.Bind
         (asyncResult: Async<Result<'T, 'TError>>,
          binder: 'T -> Async<Result<'U, 'TError>>)
         : Async<Result<'U, 'TError>> =
@@ -57,7 +57,7 @@ module AsyncResultCE =
       this.Bind(Async.AwaitTask taskResult, binder)
     #endif
 
-    member this.Bind
+    member inline this.Bind
         (result: Result<'T, 'TError>, binder: 'T -> Async<Result<'U, 'TError>>)
         : Async<Result<'U, 'TError>> =
       this.Bind(this.ReturnFrom result, binder)
@@ -109,7 +109,7 @@ module AsyncResultCE =
         this.While(enum.MoveNext,
           this.Delay(fun () -> binder enum.Current)))
 
-    member __.BindReturn(x: Async<Result<'T,'U>>, f) = AsyncResult.map f x
+    member inline __.BindReturn(x: Async<Result<'T,'U>>, f) = AsyncResult.map f x
     member __.BindReturn(x: Async<Choice<'T,'U>>, f) = __.BindReturn(x |> Async.map Result.ofChoice, f)
     member __.BindReturn(x: Result<'T,'U>, f) = __.BindReturn(x |> Async.singleton, f) 
     member __.BindReturn(x: Choice<'T,'U>, f) = __.BindReturn(x |> Result.ofChoice |> Async.singleton, f) 
@@ -173,7 +173,7 @@ module AsyncResultCEExtensions =
     #endif
 
 
-    member __.BindReturn(x: Async<'T>, f) = 
+    member inline __.BindReturn(x: Async<'T>, f) = 
       __.BindReturn(x |> Async.map Result.Ok, f)
 
     #if !FABLE_COMPILER

src/FsToolkit.ErrorHandling/ResultCE.fs

@@ -15,7 +15,7 @@ module ResultCE =
     member this.Zero () : Result<unit, 'TError> =
       this.Return ()
 
-    member __.Bind
+    member inline __.Bind
         (result: Result<'T, 'TError>, binder: 'T -> Result<'U, 'TError>)
         : Result<'U, 'TError> =
       Result.bind binder result
@@ -25,7 +25,7 @@ module ResultCE =
         : unit -> Result<'T, 'TError> =
       generator
 
-    member __.Run
+    member inline __.Run
         (generator: unit -> Result<'T, 'TError>)
         : Result<'T, 'TError> =
       generator ()

tests/FsToolkit.ErrorHandling.Tests/AsyncResultCE.fs

@@ -418,6 +418,27 @@ let ``AsyncResultCE applicative tests`` =
 
 
 
+let failureFunc () = async {
+    return failwith "I'm a failure"
+}
+
+let iDoCalls () = asyncResult {
+    let! int1 = Ok 1
+    let! int2 = Ok 2
+    do! failureFunc ()
+}
+
+
+
+
+let ``AsyncResultCE stack traces`` =
+    testList "AsyncResultCE Stack traces" [
+        testCaseAsync "Stacktrace1" <| async {
+            let! result = iDoCalls ()
+            Expect.isError result ""
+        }
+    ]
+
 let allTests = testList "AsyncResultCETests" [
     ``AsyncResultCE return Tests``
     ``AsyncResultCE return! Tests``
@@ -427,4 +448,5 @@ let allTests = testList "AsyncResultCETests" [
     ``AsyncResultCE using Tests``
     ``AsyncResultCE loop Tests``
     ``AsyncResultCE applicative tests``
+    ``AsyncResultCE stack traces``
 ]

tests/FsToolkit.ErrorHandling.Tests/ResultCE.fs

@@ -277,6 +277,25 @@ let ``ResultCE applicative tests`` =
             Expect.equal actual (Error errorMsg1) "Should be Error"
     ]
 
+
+let failureFunc () =
+    failwith "I'm a failure"
+
+
+let iDoCalls () = result {
+    let! int1 = Ok 1
+    let! int2 = Ok 2
+    do! failureFunc ()
+}
+
+
+let ``ResultCE stack traces`` =
+    ftestList "ResultCE Stack traces" [
+        testCase "Stacktrace1" <| fun () ->
+            let result = iDoCalls ()
+            Expect.isError result ""
+    ]
+
 let allTests = testList "Result CE Tests" [
     ``ResultCE return Tests``
     ``ResultCE return! Tests``
@@ -286,4 +305,5 @@ let allTests = testList "Result CE Tests" [
     ``ResultCE using Tests``
     ``ResultCE loop Tests``
     ``ResultCE applicative tests`` 
+    ``ResultCE stack traces``
 ]