Use a delayed run for TaskBuilderTests

Author: gusty

tests/FSharpPlus.Tests/Helpers.fs

@@ -14,3 +14,56 @@ module SideEffects =
     let add x = effects.Add (x)
     let get () = effects |> Seq.toList
     let are lst = areEquivalent lst (get ())
+
+module Rebuilders =
+    // following code is copied from Builders.fs with a modified Run method
+    open System
+    open System.Collections.Generic
+    open FSharpPlus
+    open FSharpPlus.Control
+
+    type StrictBuilder<'``monad<'t>``> () =
+        inherit FSharpPlus.GenericBuilders.Builder<'``monad<'t>``> ()
+        member inline _.Delay ([<InlineIfLambda>]expr) = expr : unit -> '``Monad<'T>``
+        member inline this.Run ([<InlineIfLambda>]expr: _->'``Monad<'T>``) = this.Bind (this.Return (), expr)
+        member inline _.TryWith    ([<InlineIfLambda>]expr, [<InlineIfLambda>]handler)      = TryWith.InvokeForStrict    expr handler      : '``Monad<'T>``
+        member inline _.TryFinally ([<InlineIfLambda>]expr, [<InlineIfLambda>]compensation) = TryFinally.InvokeForStrict expr compensation : '``Monad<'T>``
+        
+        member inline _.Using (disposable: #IDisposable, [<InlineIfLambda>]body) = Using.Invoke disposable body
+
+
+
+    type MonadPlusStrictBuilder<'``monad<'t>``> () =
+        inherit StrictBuilder<'``monad<'t>``> ()
+        member        _.YieldFrom expr = expr                           : '``monad<'t>``
+        member inline _.Zero () = Empty.Invoke ()                       : '``MonadPlus<'T>``
+        member inline _.Combine (a: '``MonadPlus<'T>``, [<InlineIfLambda>]b) = a <|> b () : '``MonadPlus<'T>``
+        member inline _.While ([<InlineIfLambda>]guard, [<InlineIfLambda>]body: unit -> '``MonadPlus<'T>``) : '``MonadPlus<'T>`` =
+            let rec loop guard body =
+                if guard () then body () <|> loop guard body
+                else Empty.Invoke ()
+            loop guard body
+        member inline this.For (p: #seq<'T>, [<InlineIfLambda>]rest: 'T->'``MonadPlus<'U>``) =
+            Using.Invoke (p.GetEnumerator () :> IDisposable) (fun enum ->
+                let enum = enum :?> IEnumerator<_>
+                this.While (enum.MoveNext, fun () -> rest enum.Current) : '``MonadPlus<'U>``)
+
+    type MonadFxStrictBuilder<'``monad<'t>``> () =
+        inherit StrictBuilder<'``monad<'t>``> ()
+        
+        member inline _.Zero () = result ()                                       : '``Monad<unit>``
+        member inline _.Combine (a: '``Monad<unit>``, [<InlineIfLambda>]b) = a >>= fun () -> b () : '``Monad<'T>``
+        
+        member inline _.While ([<InlineIfLambda>]guard, [<InlineIfLambda>]body: unit -> '``Monad<unit>``)             : '``Monad<unit>`` =
+            let rec loop guard body =
+                if guard () then body () >>= fun () -> loop guard body
+                else result ()
+            loop guard body
+        member inline this.For (p: #seq<'T>, [<InlineIfLambda>]rest: 'T->'``Monad<unit>``) =
+            Using.Invoke (p.GetEnumerator () :> IDisposable) (fun enum ->
+                let enum = enum :?> IEnumerator<_>
+                this.While (enum.MoveNext, fun () -> rest enum.Current) : '``Monad<unit>``)
+
+
+/// Creates a strict monadic computation expression with a delayed Run method
+let drMonad<'``monad<'t>``> = new Rebuilders.MonadFxStrictBuilder<'``monad<'t>``> ()

tests/FSharpPlus.Tests/Task.fs

@@ -282,7 +282,12 @@ module Task =
         open System.Collections.Generic
         open System.Diagnostics
         open System.Threading
-        open System.Threading.Tasks
+
+        // TaskBuilder uses a strict monad builder with delayed Run method
+        // Therefore we need to use a lazy run to avoid eager execution
+        // of the first instructions in the computation expression before
+        // the first bind, which in some tests include a Thread.Sleep operation
+        let monad'<'``monad<'t>``> = drMonad<'``monad<'t>``>
 
         module Task =
             let Yield () =
@@ -965,7 +970,7 @@ module Task =
                 testShortCircuitResult
                 testDelay
                 testNoDelay
-                (fun () -> try testNonBlocking() with _ -> try testNonBlocking() with _ -> testNonBlocking())
+                testNonBlocking
                 testCatching1
                 testCatching2
                 testNestedCatching

tests/FSharpPlus.Tests/ValueTask.fs

@@ -235,6 +235,12 @@ module ValueTask =
         open System.Collections.Generic
         open System.Diagnostics
 
+        // TaskBuilder uses a strict monad builder with a delayed Run method
+        // Therefore we need to use a lazy run to avoid eager execution
+        // of the first instructions in the computation expression before
+        // the first bind, which in some tests include a Thread.Sleep operation
+        let monad'<'``monad<'t>``> = drMonad<'``monad<'t>``>
+
         module ValueTask =
             let Yield () =
                 let ya = Task.Yield().GetAwaiter ()
@@ -916,7 +922,7 @@ module ValueTask =
                 testShortCircuitResult
                 testDelay
                 testNoDelay
-                (fun () -> try testNonBlocking() with _ -> try testNonBlocking() with _ -> testNonBlocking())
+                testNonBlocking
                 testCatching1
                 testCatching2
                 testNestedCatching