Extract helpers from large Expecto.fs file

Expecto.Diff/Library.fs

@@ -1,4 +1,5 @@
 module Expecto.Diff
+
 open System
 open DiffPlex.DiffBuilder
 open DiffPlex.DiffBuilder.Model

Expecto/Async.fs

@@ -0,0 +1,55 @@
+module internal Expecto.Async
+
+open System
+open System.Threading
+open System.Threading.Tasks
+
+let map fn a =
+  async {
+    let! v = a
+    return fn v
+  }
+
+let bind fn a =
+  async.Bind(a, fn)
+
+let foldSequentiallyWithCancel (ct: CancellationToken) folder state (s:_ seq) =
+  async {
+    let mutable state = state
+    let tcs = TaskCompletionSource()
+    use _ = Action tcs.SetResult |> ct.Register
+    let tasks: Task[] = [| null; tcs.Task |]
+    use e = s.GetEnumerator()
+    while not ct.IsCancellationRequested && e.MoveNext() do
+      let task = Async.StartAsTask e.Current
+      tasks.[0] <- task :> Task
+      if Task.WaitAny tasks = 0 then
+        state <- folder state task.Result
+    return state
+  }
+
+let foldSequentially folder state (s: _ seq) =
+  foldSequentiallyWithCancel CancellationToken.None folder state s
+
+let foldParallelWithCancel maxParallelism (ct: CancellationToken) folder state (s: _ seq) =
+  async {
+    let mutable state = state
+    use e = s.GetEnumerator()
+    if e.MoveNext() then
+      let mutable tasks = [Async.StartAsTask e.Current]
+      while not(ct.IsCancellationRequested || List.isEmpty tasks) do
+        if List.length tasks = maxParallelism || not(e.MoveNext()) then
+          while not( tasks |> List.exists (fun t -> t.IsCompleted)
+                  || ct.IsCancellationRequested) do
+            do! Async.Sleep 10
+          tasks |> List.tryFindIndex (fun t -> t.IsCompleted)
+          |> Option.iter (fun i ->
+            let a,b = List.splitAt i tasks
+            state <- (List.head b).Result |> folder state
+            tasks <- a @ List.tail b
+          )
+        else tasks <- Async.StartAsTask e.Current :: tasks
+    return state
+  }
+
+

Expecto/CSharp.fs

@@ -105,11 +105,11 @@ module Runner =
 
       /// Set the printer - this replaces the current one
       [<Extension; CompiledName("WithPrinter")>]
-      member x.WithPrinter(printer:ITestPrinter) = { x with printer = printerFromInterface printer }
+      member x.WithPrinter(printer: ITestPrinter) = { x with printer = printerFromInterface printer }
 
       /// Add an additional printer - this does not replace the current one
       [<Extension; CompiledName("AddPrinter")>]
-      member x.AddPrinter(printer:ITestPrinter) =
+      member x.AddPrinter(printer: ITestPrinter) =
         let combinedPrinter = TestPrinters.mergePrinters (x.printer, (printerFromInterface printer))
         { x with printer = combinedPrinter }
 
@@ -183,7 +183,7 @@ type Function() =
         message
     result <- r
     b
-    
+
   /// Expects function `f1` is faster than `f2`. Statistical test to 99.99%
   /// confidence level. With `setup` actions.
   static member IsFasterThan (setup1:Action, f1:Func<'a>,