perf/ci: add NuGet caching and reduce test delays

CI improvements:
- Add actions/cache@v4 for NuGet packages to test.yaml, build.yaml,
  and main.yaml. Caches ~/.nuget/packages keyed on project files and
  global.json, with a fallback restore key. This avoids re-downloading
  packages on every CI run.

Test performance improvements:
- Reduce default DummyTaskFactory delay from 10-30ms to 1-5ms
- Reduce Gen.sideEffectTaskSeq default from 10-30ms to 1-5ms
- Reduce AsyncYielded/AsyncYielded_Nested variants from 15-50ms to 1-5ms
  per task (affects 68+ theory test cases that each run 10 sequential tasks)
- Reduce longDelay() from random 20-70ms to Task.Delay(1) (~15ms on Windows)
- Reduce sideEffectTaskSeqMs 200-400ms calls in IsEmpty and ExactlyOne
  tests to sideEffectTaskSeqMicro 1-5ms

The async yield point (Task.Delay 0 inside delayTask, and the real timer
in longDelay) is preserved so tests still verify behaviour with genuine
async suspensions. Only the wall-clock waiting time is reduced.

Closes #290

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

.github/workflows/build.yaml

@@ -15,6 +15,13 @@ jobs:
 
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
 
       - name: tool restore
         run: dotnet tool restore
@@ -36,6 +43,14 @@ jobs:
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
 
+      # cache NuGet packages to avoid re-downloading on every run
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
+
       # build it, test it, pack it
       - name: Run dotnet build (release)
         # see issue #105

.github/workflows/main.yaml

@@ -18,6 +18,13 @@ jobs:
       # setup dotnet based on global.json
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
+      # cache NuGet packages to avoid re-downloading on every run
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
       # build it, test it, pack it
       - name: Run dotnet build (release)
         # see issue #105
@@ -37,6 +44,13 @@ jobs:
       # setup dotnet based on global.json
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
+      # cache NuGet packages to avoid re-downloading on every run
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
       # build it, test it, pack it
       - name: Run dotnet test - release
         # see issue #105

.github/workflows/test.yaml

@@ -17,6 +17,14 @@ jobs:
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
 
+      # cache NuGet packages to avoid re-downloading on every run
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
+
       # build it, test it
       - name: Run dotnet test - release
         # see issue #105
@@ -47,6 +55,14 @@ jobs:
       - name: setup-dotnet
         uses: actions/setup-dotnet@v4
 
+      # cache NuGet packages to avoid re-downloading on every run
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.fsproj', '**/*.csproj', 'global.json') }}
+          restore-keys: nuget-${{ runner.os }}-
+
       # build it, test it
       - name: Run dotnet test - debug
         # see issue #105

src/FSharp.Control.TaskSeq.Test/TaskSeq.ExactlyOne.Tests.fs

@@ -104,7 +104,7 @@ module Other =
     [<Fact>]
     let ``TaskSeq-exactlyOne gets the only item in a singleton sequence - variant`` () = task {
         let! exactlyOne =
-            Gen.sideEffectTaskSeqMs 50<ms> 300<ms> 1
+            Gen.sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 1
             |> TaskSeq.exactlyOne
 
         exactlyOne |> should equal 1
@@ -113,7 +113,7 @@ module Other =
     [<Fact>]
     let ``TaskSeq-tryExactlyOne gets the only item in a singleton sequence - variant`` () = task {
         let! exactlyOne =
-            Gen.sideEffectTaskSeqMs 50<ms> 300<ms> 1
+            Gen.sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 1
             |> TaskSeq.tryExactlyOne
 
         exactlyOne |> should be Some'

src/FSharp.Control.TaskSeq.Test/TaskSeq.IsEmpty.fs

@@ -28,7 +28,7 @@ module Immutable =
 
     [<Fact>]
     let ``TaskSeq-isEmpty returns false for delayed singleton sequence`` () =
-        Gen.sideEffectTaskSeqMs 200<ms> 400<ms> 3
+        Gen.sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 3
         |> TaskSeq.isEmpty
         |> Task.map (should be False)
 

src/FSharp.Control.TaskSeq.Test/TestUtils.fs

@@ -98,9 +98,9 @@ type DummyTaskFactory(µsecMin: int64<µs>, µsecMax: int64<µs>) =
     /// Creates dummy tasks with a randomized delay and a mutable state,
     /// to ensure we properly test whether processing is done ordered or not.
     /// Uses the defaults for <paramref name="µsecMin" /> and <paramref name="µsecMax" />
-    /// with 10,000µs and 30,000µs respectively (or 10ms and 30ms).
+    /// with 1,000µs and 5,000µs respectively (or 1ms and 5ms).
     /// </summary>
-    new() = DummyTaskFactory(10_000L<µs>, 30_000L<µs>)
+    new() = DummyTaskFactory(1_000L<µs>, 5_000L<µs>)
 
     /// <summary>
     /// Creates dummy tasks with a randomized delay and a mutable state,
@@ -164,8 +164,9 @@ module TestUtils =
         >> TaskSeq.toArrayAsync
         >> Task.map (String >> should equal expected)
 
-    /// Delays (no spin-wait!) between 20 and 70ms, assuming a 15.6ms resolution clock
-    let longDelay () = task { do! Task.Delay(Random().Next(20, 70)) }
+    /// Waits using a real timer-based async delay (not spin-wait), causing an OS-level async yield point.
+    /// On Windows, Task.Delay has ~15ms timer resolution, so this actually waits ~15ms.
+    let longDelay () = task { do! Task.Delay 1 }
 
     /// Spin-waits, occasionally normal delay, between 50µs - 18,000µs
     let microDelay () = task { do! DelayHelper.delayTask 50L<µs> 18_000L<µs> (fun _ -> ()) }
@@ -324,8 +325,8 @@ module TestUtils =
                     yield x
             }
 
-        /// Create a bunch of dummy tasks, each lasting between 10-30ms with spin-wait delays.
-        let sideEffectTaskSeq = sideEffectTaskSeqMicro 10_000L<µs> 30_000L<µs>
+        /// Create a bunch of dummy tasks, each lasting between 1-5ms with spin-wait delays.
+        let sideEffectTaskSeq = sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs>
 
         /// Returns any of a set of variants that each create an empty sequence in a creative way.
         /// Please extend this with more cases.
@@ -428,7 +429,7 @@ module TestUtils =
             | SeqImmutable.AsyncYielded ->
                 // by returning the 'side effect seq' from the closure of the CE,
                 // the side-effect will NOT execute again
-                taskSeq { yield! sideEffectTaskSeqMicro 15_000L<µs> 50_000L<µs> 10 }
+                taskSeq { yield! sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 10 }
             | SeqImmutable.AsyncYielded_Nested ->
                 // let's deeply nest the sequence, which should not cause extra side effects being executed.
                 taskSeq {
@@ -442,7 +443,7 @@ module TestUtils =
                                                 yield! taskSeq {
                                                     // by returning the 'side effect seq' from the closure of the CE,
                                                     // the side-effect will NOT execute again
-                                                    yield! sideEffectTaskSeqMicro 15_000L<µs> 50_000L<µs> 10
+                                                    yield! sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 10
                                                 }
                                             }
                                         }
@@ -520,12 +521,12 @@ module TestUtils =
 
             // delay just enough with a spin-wait to occasionally cause a thread-yield
             | SeqWithSideEffect.ThreadSpinWait -> sideEffectTaskSeqMicro 50L<µs> 5_000L<µs> 10
-            | SeqWithSideEffect.AsyncYielded -> sideEffectTaskSeqMicro 15_000L<µs> 50_000L<µs> 10
+            | SeqWithSideEffect.AsyncYielded -> sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 10
             | SeqWithSideEffect.AsyncYielded_Nested ->
                 // let's deeply nest the sequence, which should not cause extra side effects being executed.
                 // NOTE: this list of tasks must be defined OUTSIDE the scope, otherwise, mutability on 2nd
                 //       iteration will not kick in!
-                let nestedTaskSeq = sideEffectTaskSeqMicro 15_000L<µs> 50_000L<µs> 10
+                let nestedTaskSeq = sideEffectTaskSeqMicro 1_000L<µs> 5_000L<µs> 10
 
                 taskSeq {
                     yield! taskSeq {