Adds bind CE and bind same benchmarks

Author: TheAngryByrd

benchmarks/Benchmarks.fs

@@ -7,10 +7,11 @@ open BenchmarkDotNet.Attributes
 
 let okF x = x + 2
 let errorF x = x - 4
-
 let add x y = x + y
 
 module Result =
+
+//     let inline (|>>) ([<InlineIfLambda>] v : _ -> _) ([<InlineIfLambda>] f : _ -> _) = f v    
     module Normal =
 
         let either okF errorF x =
@@ -38,13 +39,9 @@ module Result =
             let eitherMap (okF) (errorF) x =
                 either (fun x -> x |> okF |> Result.Ok) (fun y -> y |> errorF |> Result.Error) x
 
-            let bind (f) x =
-                match x with
-                | Ok x -> f x
-                | Error e -> Error e
             let apply (f) x =
-                bind (fun f' ->
-                    bind (fun x -> f' x |> Ok) x) f
+                Result.bind (fun f' ->
+                    Result.bind (fun x -> f' x |> Ok) x) f
             let map2 (f) x y =
                 (apply (apply (Ok f) x) y)
 
@@ -174,7 +171,23 @@ module Result =
                 | Error e, _ -> Error e
                 | _ , Error e -> Error e
 
-            let inline map2 ([<InlineIfLambda>] f) x y =
+            let inline map ([<InlineIfLambda>] mapper : 'ok -> 'ok2) value  =
+                match value with
+                | Ok x -> Ok(mapper x)
+                | Error e -> Error e
+
+
+            let inline bindSame ([<InlineIfLambda>] binder: 'ok -> Result<'ok, 'err>) value  =
+                match value with
+                | Ok x -> binder x
+                | Error _ -> value
+
+            let inline bind ([<InlineIfLambda>] binder: 'ok -> Result<'ok2, 'err>) value  =
+                match value with
+                | Ok x -> binder x
+                | Error e -> Error e
+
+            let inline map2 ([<InlineIfLambda>] f : 'a -> 'b -> 'c) x y =
                 match x, y with
                 | Ok x, Ok y -> f x y |> Ok
                 | Error e as z, _ -> Error e
@@ -191,7 +204,7 @@ type EitherMapBenchmarks () =
     member this.Result_Normal_NoComposition_EitherMap () =
         Ok 4
         |> Result.Normal.NoComposition.eitherMap okF errorF 
-        
+
     [<Benchmark>]
     member this.Result_Inlined_EitherMap () =
         Ok 4
@@ -224,6 +237,133 @@ type EitherMapBenchmarks () =
         |> Result.Alt.InlinedLambda.eitherMap okF errorF 
 
 
+type ResultBuilder() =
+    member __.Return(value: 'T) : Result<'T, 'TError> = Ok value
+
+    // member inline __.ReturnFrom(result: Result<'T, 'TError>) : Result<'T, 'TError> = result
+
+    member this.Zero() : Result<unit, 'TError> = this.Return()
+
+    member __.Bind(result: Result<'T, 'TError>, binder: 'T -> Result<'U, 'TError>) : Result<'U, 'TError> =
+        Result.bind binder result
+
+
+type ResultBuilderInlined() =
+    member inline __.Return(value: 'T) : Result<'T, 'TError> = Ok value
+
+    // member inline __.ReturnFrom(result: Result<'T, 'TError>) : Result<'T, 'TError> = result
+
+    member inline this.Zero() : Result<unit, 'TError> = this.Return()
+
+    member inline __.Bind(result: Result<'T, 'TError>, binder: 'T -> Result<'U, 'TError>) : Result<'U, 'TError> =
+        Result.Inlined.bind binder result
+
+type ResultBuilderInlinedLambda() =
+    member inline __.Return(value: 'T) : Result<'T, 'TError> = Ok value
+
+    member inline this.Zero() : Result<unit, 'TError> = this.Return()
+
+    member inline __.Bind(result: Result<'T, 'TError>, [<InlineIfLambda>] binder: 'T -> Result<'T, 'TError>) : Result<'T, 'TError> =
+        Result.Alt.InlinedLambda.bindSame binder result
+
+[<AutoOpen>]
+module ResultCEExtensions =
+    type ResultBuilderInlinedLambda with
+        member inline __.Bind(result: Result<'T, 'TError>, [<InlineIfLambda>]binder: 'T -> Result<'U, 'TError>) : Result<'U, 'TError> =
+            Result.Alt.InlinedLambda.bind binder result
+
+let result = ResultBuilder()
+let resultInlined = ResultBuilderInlined()
+let resultInlinedLambda = ResultBuilderInlinedLambda()
+[<MemoryDiagnoser>]
+type MapBenchmarks () =
+    [<Benchmark(Baseline = true)>]
+    member this.Result_Normal_Map ()  = 
+        Result.map (fun x -> x + 2 ) (Ok 1)  : Result<_,int>
+
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_Map ()  = 
+        Result.Alt.InlinedLambda.map (fun x -> x + 2 ) (Ok 1)  : Result<_,int>
+
+let runTimes x action =
+    let results = ResizeArray<_>()
+    for i=1 to x do
+        action() |> results.Add
+    results
+
+[<MemoryDiagnoser>]
+type BindSameBenchmarks () =
+    [<Benchmark(Baseline = true)>]
+    member this.Result_Alt_InlinedLambda_Bind () : ResizeArray<Result<int,string>> = 
+        runTimes 1000 (fun () -> Result.Alt.InlinedLambda.bind (fun x -> Ok(x + 2) ) (Ok 1) )
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_BindSame () : ResizeArray<Result<int,string>> = 
+        runTimes 1000 (fun () -> Result.Alt.InlinedLambda.bindSame (fun x -> Ok(x + 2) ) (Ok 1) )
+
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_Bind_Error () : ResizeArray<Result<int,string>>  = 
+        runTimes 1000 (fun () -> Result.Alt.InlinedLambda.bind (fun x -> Ok(x + 2) ) (Error "no"))
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_BindSame_Error () : ResizeArray<Result<int,string>> = 
+        runTimes 1000 (fun () -> Result.Alt.InlinedLambda.bindSame (fun x -> Ok(x + 2) ) (Error "no"))
+
+[<MemoryDiagnoser>]
+type BindBenchmarks () =
+    [<Benchmark(Baseline = true)>]
+    member this.Result_Normal_Bind ()  = 
+        Result.bind (fun x -> Ok(x + 2) ) (Ok 1) : Result<int,int>
+
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_Bind ()  = 
+        Result.Alt.InlinedLambda.bind (fun x -> Ok(x + 2) ) (Ok 1) : Result<int,int>
+
+let divide x y = 
+    match y with
+    | 0 -> Error "Cannot divide by 0"
+    | _ -> Ok (x/y)
+
+[<MemoryDiagnoser>]
+type BindCEBenchmarks () =
+    [<Benchmark(Baseline = true)>]
+    member this.Result_Normal_Bind_CE()  = 
+        let action () = result {
+            let! a = Ok 1
+            let! b = Ok 3
+            let! c = divide a b
+            return c
+        }
+        action ()
+
+    [<Benchmark>]
+    member this.Result_Alt_Inlined_Bind_CE ()  = 
+        let action () = resultInlined {
+            let! a = Ok 1
+            let! b = Ok 3
+            let! c = divide a b
+            return c
+        }
+        action ()
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_Bind_CE ()  = 
+        let action () = resultInlinedLambda {
+            let! a = Ok 1
+            let! b = Ok 3
+            let! c = divide a b
+            return c
+        }
+        action ()
+
+    [<Benchmark>]
+    member this.Result_Alt_InlinedLambda_Bind_CE2 () : Result<int,string> = 
+        let action () = resultInlinedLambda {
+            let! a = Ok 1
+            let! b = Ok 3.0
+            let! c = divide a (int b)
+            return c
+        }
+        action ()
+
+
 [<MemoryDiagnoser>]
 type Map2Benchmarks () =
 
@@ -250,17 +390,11 @@ type Map2Benchmarks () =
 
     [<Benchmark>]
     member this.Result_Alt_Map2 () = 
-        
         Result.Alt.map2 add (Ok 1) (Ok 2) : Result<int,int>
     [<Benchmark>]
     member this.Result_Alt_Inlined_Map2 () = 
-        
         Result.Alt.Inlined.map2 add (Ok 1) (Ok 2) : Result<int,int>
-
     [<Benchmark>]
     member this.Result_Alt_InlinedLambda_Map2 () =         
         Result.Alt.InlinedLambda.map2 add (Ok 1) (Ok 2) : Result<int,int>
-        
-    [<Benchmark>]
-    member this.Result_Alt_InlinedLambda2_Map2 () =         
-        Result.Alt.InlinedLambda.map2 (fun x y -> x + y) (Ok 1) (Ok 2) : Result<int,int>
+        

benchmarks/Program.fs

@@ -5,6 +5,8 @@ open benchmarks
 [<EntryPoint>]
 let main argv =
     // BenchmarkRunner.Run<EitherMapBenchmarks>() |> ignore
-    BenchmarkRunner.Run<Map2Benchmarks>() |> ignore
+    // BenchmarkRunner.Run<BindCEBenchmarks>() |> ignore
+    BenchmarkRunner.Run<BindSameBenchmarks>() |> ignore
+// 
 
     0 // return an integer exit code

benchmarks/benchmarks.fsproj

@@ -4,6 +4,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <LangVersion>preview</LangVersion>
+    <WarnOn>3517</WarnOn>
   </PropertyGroup>
   <PropertyGroup>
     <PlatformTarget>AnyCPU</PlatformTarget>