Merge branch 'main' into daily-perf-improver/fix-append-memory-leak

Author: dsyme

.github/actions/daily-perf-improver/build-steps/action.yml

@@ -0,0 +1,50 @@
+name: 'Daily Perf Improver Build Steps'
+description: 'Sets up the environment and builds FSharp.Control.AsyncSeq for performance testing and development'
+runs:
+  using: 'composite'
+  steps:
+    - name: Setup .NET SDK
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: '8.0.x'
+        dotnet-quality: 'ga'
+    
+    - name: Restore dependencies
+      shell: bash
+      run: dotnet restore
+      
+    - name: Build solution in Release mode
+      shell: bash
+      run: dotnet build -c Release --no-restore
+      
+    - name: Run tests to verify build
+      shell: bash
+      run: dotnet test -c Release --no-build --logger trx --results-directory TestResults/
+      
+    - name: Run performance baseline test
+      shell: bash
+      run: dotnet fsi tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqPerf.fsx
+      
+    - name: Setup tools for performance analysis
+      shell: bash
+      run: |
+        # Install dotnet tools for performance analysis (if needed)
+        echo "Build environment ready for performance testing"
+        echo "Available tools:"
+        echo "- dotnet build/test for regular builds"
+        echo "- dotnet fsi for F# Interactive and performance scripts"
+        echo "- Release builds available in src/FSharp.Control.AsyncSeq/bin/Release/"
+        echo "- Test results in TestResults/"
+        
+    - name: Display environment info
+      shell: bash
+      run: |
+        echo "=== Environment Information ==="
+        echo "Operating System: $(uname -a)"
+        echo ".NET Version: $(dotnet --version)"
+        echo "F# Compiler: $(dotnet fsc --version 2>/dev/null || echo 'F# Compiler available via dotnet')"
+        echo "Working Directory: $(pwd)"
+        echo "Available cores: $(nproc)"
+        echo "Memory: $(free -h | head -n 2)"
+        echo "=== Build Artifacts ==="
+        find src/FSharp.Control.AsyncSeq/bin/Release -type f -name "*.dll" 2>/dev/null || echo "No build artifacts found"

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1419,6 +1419,11 @@ module AsyncSeq =
   let interleave (source1:AsyncSeq<'T>) (source2:AsyncSeq<'T>) : AsyncSeq<'T> =
     interleaveChoice source1 source2 |> map (function Choice1Of2 x -> x | Choice2Of2 x -> x)
 
+  let interleaveMany (xs : #seq<AsyncSeq<'T>>) : AsyncSeq<'T> =
+    let mutable result = empty
+    for x in xs do
+      result <- interleave result x
+    result
 
   let bufferByCount (bufferSize:int) (source:AsyncSeq<'T>) : AsyncSeq<'T[]> =
     if (bufferSize < 1) then invalidArg "bufferSize" "must be positive"

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -462,11 +462,15 @@ module AsyncSeq =
     /// large or infinite sequences.
     val sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> array<'T> when 'Key : comparison
     #endif
-    
+
     /// Interleaves two async sequences of the same type into a resulting sequence. The provided
     /// sequences are consumed in lock-step.
     val interleave : source1:AsyncSeq<'T> -> source2:AsyncSeq<'T> -> AsyncSeq<'T>
 
+    /// Interleaves a sequence of async sequences into a resulting async sequence. The provided
+    /// sequences are consumed in lock-step.
+    val interleaveMany : source:#seq<AsyncSeq<'T>> -> AsyncSeq<'T>
+
     /// Interleaves two async sequences into a resulting sequence. The provided
     /// sequences are consumed in lock-step.
     val interleaveChoice  : source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<Choice<'T1,'T2>>

tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqTests.fs

@@ -406,6 +406,25 @@ let ``AsyncSeq.interleave first empty``() =
   let merged = AsyncSeq.interleave s1 s2 |> AsyncSeq.toListSynchronously
   Assert.True([1 ; 2 ; 3] = merged)
 
+[<Test>]
+let ``AsyncSeq.interleaveMany empty``() =
+  let merged = AsyncSeq.interleaveMany [] |> AsyncSeq.toListSynchronously
+  Assert.True(List.isEmpty merged)
+
+[<Test>]
+let ``AsyncSeq.interleaveMany 1``() =
+  let s1 = AsyncSeq.ofSeq ["a";"b";"c"]
+  let merged = AsyncSeq.interleaveMany [s1] |> AsyncSeq.toListSynchronously
+  Assert.True(["a" ; "b" ; "c" ] = merged)
+
+[<Test>]
+let ``AsyncSeq.interleaveMany 3``() =
+  let s1 = AsyncSeq.ofSeq ["a";"b"]
+  let s2 = AsyncSeq.ofSeq ["i";"j";"k";"l"]
+  let s3 = AsyncSeq.ofSeq ["x";"y";"z"]
+  let merged = AsyncSeq.interleaveMany [s1;s2;s3] |> AsyncSeq.toListSynchronously
+  Assert.True(["a"; "x"; "i"; "y"; "b"; "z"; "j"; "k"; "l"] = merged)
+
 
 [<Test>]
 let ``AsyncSeq.bufferByCount``() =