Merge branch 'main' into repo-assist/improve-insert-remove-splitinto-20260427-c538b1cd17009ced

Author: dsyme

.github/aw/actions-lock.json

@@ -5,15 +5,20 @@
       "version": "v6.0.2",
       "sha": "de0fac2e4500dabe0009e67214ff5f5447ce83dd"
     },
+    "actions/github-script@v9": {
+      "repo": "actions/github-script",
+      "version": "v9",
+      "sha": "3a2844b7e9c422d3c10d287c895573f7108da1b3"
+    },
     "actions/github-script@v9.0.0": {
       "repo": "actions/github-script",
       "version": "v9.0.0",
       "sha": "d746ffe35508b1917358783b479e04febd2b8f71"
     },
-    "github/gh-aw-actions/setup@v0.68.3": {
+    "github/gh-aw-actions/setup@v0.71.3": {
       "repo": "github/gh-aw-actions/setup",
-      "version": "v0.68.3",
-      "sha": "ba90f2186d7ad780ec640f364005fa24e797b360"
+      "version": "v0.71.3",
+      "sha": "07c7335cd76c4d4d9f00dd7874f85ff55ed71f24"
     },
     "github/gh-aw/actions/setup@v0.68.7": {
       "repo": "github/gh-aw/actions/setup",

.github/workflows/repo-assist.lock.yml

@@ -14,7 +14,7 @@ description: |
   Always polite, constructive, and mindful of the project's goals.
 
 on:
-  schedule: every 2d
+  schedule: weekly
   workflow_dispatch:
   slash_command:
     name: repo-assist

.github/workflows/repo-assist.md

@@ -1,9 +1,18 @@
+### 4.17.0
+
+* Performance: Optimised `AsyncSeq.pairwise` to use a `hasPrev` flag and a direct `mutable` field instead of wrapping the previous element in `Some`. Previously, each iteration allocated a new `'T option` object on the heap; the new implementation eliminates that allocation entirely, reducing GC pressure for long sequences.
+* Bug fix: `AsyncSeq.splitAt` and `AsyncSeq.tryTail` now correctly dispose the underlying enumerator when an exception or cancellation occurs during the initial `MoveNext` call. Previously the enumerator could leak if the source sequence threw during the first few steps.
+
 ### 4.16.0
 
 * Performance: Replaced `ref` cells with `mutable` locals in the `ofSeq`, `tryWith`, and `tryFinally` enumerator state machines. Each call to `ofSeq` (or any async CE block using `try...with` / `try...finally` / `use`) previously heap-allocated a `Ref<T>` wrapper object per enumerator; it now uses a direct mutable field in the generated class, reducing GC pressure. The change is equivalent to the `mutable`-for-`ref` improvement introduced in 4.11.0 for other enumerators.
 * Added `AsyncSeq.insertManyAt` — inserts multiple values before the element at the specified index; mirrors `Seq.insertManyAt` / `List.insertManyAt`.
 * Added `AsyncSeq.removeManyAt` — removes a range of elements starting at the specified index; mirrors `Seq.removeManyAt` / `List.removeManyAt`.
 * Added `AsyncSeq.splitInto` — splits the sequence into at most N chunks of as-equal-as-possible size; mirrors `Seq.splitInto` / `Array.splitInto`.
+* Added `AsyncSeq.unzip` — splits an async sequence of pairs into two arrays. Mirrors `List.unzip`.
+* Added `AsyncSeq.unzip3` — splits an async sequence of triples into three arrays. Mirrors `List.unzip3`.
+* Added `AsyncSeq.map2` — applies a function to corresponding elements of two async sequences; stops when either is exhausted. Mirrors `Seq.map2`.
+* Added `AsyncSeq.map3` — applies a function to corresponding elements of three async sequences; stops when any is exhausted. Mirrors `List.map3`.
 
 ### 4.15.0
 

RELEASE_NOTES.md

@@ -1306,13 +1306,14 @@ module AsyncSeq =
       use ie = source.GetEnumerator()
       let! v = ie.MoveNext()
       let mutable b = v
-      let mutable prev = None
+      // Use a flag + mutable field instead of Option to avoid per-element heap allocation
+      let mutable hasPrev = false
+      let mutable prev = Unchecked.defaultof<'T>
       while b.IsSome do
           let v = b.Value
-          match prev with
-          | None -> ()
-          | Some p -> yield (p, v)
-          prev <- Some v
+          if hasPrev then yield (prev, v)
+          hasPrev <- true
+          prev <- v
           let! moven = ie.MoveNext()
           b <- moven }
 
@@ -2015,6 +2016,42 @@ module AsyncSeq =
           let! next1 = ie1.MoveNext()
           b1 <- next1 }
 
+  let unzip (source: AsyncSeq<'T1 * 'T2>) : Async<'T1[] * 'T2[]> = async {
+      let as1 = System.Collections.Generic.List<'T1>()
+      let as2 = System.Collections.Generic.List<'T2>()
+      use ie = source.GetEnumerator()
+      let! move = ie.MoveNext()
+      let mutable cur = move
+      while cur.IsSome do
+          let (a, b) = cur.Value
+          as1.Add(a)
+          as2.Add(b)
+          let! next = ie.MoveNext()
+          cur <- next
+      return (as1.ToArray(), as2.ToArray()) }
+
+  let unzip3 (source: AsyncSeq<'T1 * 'T2 * 'T3>) : Async<'T1[] * 'T2[] * 'T3[]> = async {
+      let as1 = System.Collections.Generic.List<'T1>()
+      let as2 = System.Collections.Generic.List<'T2>()
+      let as3 = System.Collections.Generic.List<'T3>()
+      use ie = source.GetEnumerator()
+      let! move = ie.MoveNext()
+      let mutable cur = move
+      while cur.IsSome do
+          let (a, b, c) = cur.Value
+          as1.Add(a)
+          as2.Add(b)
+          as3.Add(c)
+          let! next = ie.MoveNext()
+          cur <- next
+      return (as1.ToArray(), as2.ToArray(), as3.ToArray()) }
+
+  let map2 (mapping: 'T1 -> 'T2 -> 'U) (source1: AsyncSeq<'T1>) (source2: AsyncSeq<'T2>) : AsyncSeq<'U> =
+      zipWith mapping source1 source2
+
+  let map3 (mapping: 'T1 -> 'T2 -> 'T3 -> 'U) (source1: AsyncSeq<'T1>) (source2: AsyncSeq<'T2>) (source3: AsyncSeq<'T3>) : AsyncSeq<'U> =
+      zipWith3 mapping source1 source2 source3
+
   let zappAsync (fs:AsyncSeq<'T -> Async<'U>>) (s:AsyncSeq<'T>) : AsyncSeq<'U> =
       zipWithAsync (|>) s fs
 
@@ -2173,51 +2210,59 @@ module AsyncSeq =
 
   let tryTail (source: AsyncSeq<'T>) : Async<AsyncSeq<'T> option> = async {
     let ie = source.GetEnumerator()
-    let! first = ie.MoveNext()
-    match first with
-    | None ->
+    try
+        let! first = ie.MoveNext()
+        match first with
+        | None ->
+            ie.Dispose()
+            return None
+        | Some _ ->
+            return Some (asyncSeq {
+                try
+                    let! next = ie.MoveNext()
+                    let mutable b = next
+                    while b.IsSome do
+                        yield b.Value
+                        let! moven = ie.MoveNext()
+                        b <- moven
+                finally
+                    ie.Dispose() })
+    with ex ->
         ie.Dispose()
-        return None
-    | Some _ ->
-        return Some (asyncSeq {
-            try
-                let! next = ie.MoveNext()
-                let mutable b = next
-                while b.IsSome do
-                    yield b.Value
-                    let! moven = ie.MoveNext()
-                    b <- moven
-            finally
-                ie.Dispose() }) }
+        return raise ex }
 
   /// Splits an async sequence at the given index, returning the first `count` elements as an array
   /// and the remaining elements as a new AsyncSeq. The source is enumerated once.
   let splitAt (count: int) (source: AsyncSeq<'T>) : Async<'T array * AsyncSeq<'T>> = async {
       if count < 0 then invalidArg "count" "must be non-negative"
       let ie = source.GetEnumerator()
-      let ra = ResizeArray<'T>()
-      let! m = ie.MoveNext()
-      let mutable b = m
-      while b.IsSome && ra.Count < count do
-          ra.Add b.Value
-          let! next = ie.MoveNext()
-          b <- next
-      let first = ra.ToArray()
-      let rest =
-          if b.IsNone then
-              ie.Dispose()
-              empty<'T>
-          else
-              let cur = ref b
-              asyncSeq {
-                  try
-                      while cur.Value.IsSome do
-                          yield cur.Value.Value
-                          let! next = ie.MoveNext()
-                          cur.Value <- next
-                  finally
-                      ie.Dispose() }
-      return first, rest }
+      try
+          let ra = ResizeArray<'T>()
+          let! m = ie.MoveNext()
+          let mutable b = m
+          while b.IsSome && ra.Count < count do
+              ra.Add b.Value
+              let! next = ie.MoveNext()
+              b <- next
+          let first = ra.ToArray()
+          let rest =
+              if b.IsNone then
+                  ie.Dispose()
+                  empty<'T>
+              else
+                  let mutable cur = b
+                  asyncSeq {
+                      try
+                          while cur.IsSome do
+                              yield cur.Value
+                              let! next = ie.MoveNext()
+                              cur <- next
+                      finally
+                          ie.Dispose() }
+          return first, rest
+      with ex ->
+          ie.Dispose()
+          return raise ex }
 
   let toArrayAsync (source : AsyncSeq<'T>) : Async<'T[]> = async {
       let ra = (new ResizeArray<_>())

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -590,6 +590,22 @@ module AsyncSeq =
     /// The second sequence is fully buffered before iteration begins, mirroring Seq.allPairs.
     val allPairs : source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<'T1 * 'T2>
 
+    /// Splits an async sequence of pairs into two arrays. Mirrors List.unzip.
+    val unzip : source:AsyncSeq<'T1 * 'T2> -> Async<'T1[] * 'T2[]>
+
+    /// Splits an async sequence of triples into three arrays. Mirrors List.unzip3.
+    val unzip3 : source:AsyncSeq<'T1 * 'T2 * 'T3> -> Async<'T1[] * 'T2[] * 'T3[]>
+
+    /// Builds a new async sequence whose elements are the results of applying the given
+    /// function to the corresponding elements of the two sequences. Stops when either
+    /// sequence is exhausted. Mirrors Seq.map2.
+    val map2 : mapping:('T1 -> 'T2 -> 'U) -> source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> AsyncSeq<'U>
+
+    /// Builds a new async sequence whose elements are the results of applying the given
+    /// function to the corresponding elements of three sequences. Stops when any
+    /// sequence is exhausted. Mirrors List.map3.
+    val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> source1:AsyncSeq<'T1> -> source2:AsyncSeq<'T2> -> source3:AsyncSeq<'T3> -> AsyncSeq<'U>
+
     /// Builds a new asynchronous sequence whose elements are generated by
     /// applying the specified function to all elements of the input sequence.
     ///

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -2816,6 +2816,13 @@ let ``AsyncSeq.pairwise with three elements should produce two pairs`` () =
   let result = AsyncSeq.pairwise source |> AsyncSeq.toListSynchronously
   Assert.AreEqual([(1, 2); (2, 3)], result)
 
+[<Test>]
+let ``AsyncSeq.pairwise with many elements produces correct pairs`` () =
+  let source = AsyncSeq.ofSeq [1..10]
+  let result = AsyncSeq.pairwise source |> AsyncSeq.toListSynchronously
+  let expected = [(1,2); (2,3); (3,4); (4,5); (5,6); (6,7); (7,8); (8,9); (9,10)]
+  Assert.AreEqual(expected, result)
+
 [<Test>]
 let ``AsyncSeq.windowed empty sequence returns empty`` () =
   let result = AsyncSeq.windowed 3 AsyncSeq.empty<int> |> AsyncSeq.toListSynchronously
@@ -3684,7 +3691,79 @@ let ``AsyncSeq.allPairs returns empty when second source is empty`` () =
     |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
   Assert.AreEqual([||], result)
 
-// ── AsyncSeq.rev ─────────────────────────────────────────────────────────────
+// ── AsyncSeq.unzip ───────────────────────────────────────────────────────────
+
+[<Test>]
+let ``AsyncSeq.unzip splits pairs into two arrays`` () =
+  let source = asyncSeq { yield (1, 'a'); yield (2, 'b'); yield (3, 'c') }
+  let (lefts, rights) = AsyncSeq.unzip source |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3 |], lefts)
+  Assert.AreEqual([| 'a'; 'b'; 'c' |], rights)
+
+[<Test>]
+let ``AsyncSeq.unzip empty source returns two empty arrays`` () =
+  let (lefts, rights) = AsyncSeq.unzip AsyncSeq.empty<int * string> |> Async.RunSynchronously
+  Assert.AreEqual([||], lefts)
+  Assert.AreEqual([||], rights)
+
+[<Test>]
+let ``AsyncSeq.unzip mirrors List.unzip`` () =
+  let pairs = [ (1, 'x'); (2, 'y'); (3, 'z') ]
+  let (expL, expR) = List.unzip pairs
+  let (actL, actR) = AsyncSeq.unzip (AsyncSeq.ofList pairs) |> Async.RunSynchronously
+  Assert.AreEqual(expL |> Array.ofList, actL)
+  Assert.AreEqual(expR |> Array.ofList, actR)
+
+// ── AsyncSeq.unzip3 ──────────────────────────────────────────────────────────
+
+[<Test>]
+let ``AsyncSeq.unzip3 splits triples into three arrays`` () =
+  let source = asyncSeq { yield (1, 'a', true); yield (2, 'b', false); yield (3, 'c', true) }
+  let (as1, as2, as3) = AsyncSeq.unzip3 source |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3 |], as1)
+  Assert.AreEqual([| 'a'; 'b'; 'c' |], as2)
+  Assert.AreEqual([| true; false; true |], as3)
+
+[<Test>]
+let ``AsyncSeq.unzip3 empty source returns three empty arrays`` () =
+  let (as1, as2, as3) = AsyncSeq.unzip3 AsyncSeq.empty<int * string * bool> |> Async.RunSynchronously
+  Assert.AreEqual([||], as1)
+  Assert.AreEqual([||], as2)
+  Assert.AreEqual([||], as3)
+
+// ── AsyncSeq.map2 ────────────────────────────────────────────────────────────
+
+[<Test>]
+let ``AsyncSeq.map2 applies function pairwise`` () =
+  let s1 = asyncSeq { yield 1; yield 2; yield 3 }
+  let s2 = asyncSeq { yield 10; yield 20; yield 30 }
+  let result = AsyncSeq.map2 (+) s1 s2 |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 11; 22; 33 |], result)
+
+[<Test>]
+let ``AsyncSeq.map2 stops at shorter sequence`` () =
+  let s1 = asyncSeq { yield 1; yield 2; yield 3 }
+  let s2 = asyncSeq { yield 10; yield 20 }
+  let result = AsyncSeq.map2 (+) s1 s2 |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 11; 22 |], result)
+
+// ── AsyncSeq.map3 ────────────────────────────────────────────────────────────
+
+[<Test>]
+let ``AsyncSeq.map3 applies function to three sequences`` () =
+  let s1 = asyncSeq { yield 1; yield 2; yield 3 }
+  let s2 = asyncSeq { yield 10; yield 20; yield 30 }
+  let s3 = asyncSeq { yield 100; yield 200; yield 300 }
+  let result = AsyncSeq.map3 (fun a b c -> a + b + c) s1 s2 s3 |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 111; 222; 333 |], result)
+
+[<Test>]
+let ``AsyncSeq.map3 stops at shortest sequence`` () =
+  let s1 = asyncSeq { yield 1; yield 2; yield 3 }
+  let s2 = asyncSeq { yield 10; yield 20; yield 30 }
+  let s3 = asyncSeq { yield 100 }
+  let result = AsyncSeq.map3 (fun a b c -> a + b + c) s1 s2 s3 |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 111 |], result)
 
 [<Test>]
 let ``AsyncSeq.rev reverses a sequence`` () =
@@ -3746,6 +3825,19 @@ let ``AsyncSeq.splitAt with negative count throws ArgumentException`` () =
   Assert.Throws<System.ArgumentException>(fun () ->
     AsyncSeq.splitAt -1 AsyncSeq.empty<int> |> Async.RunSynchronously |> ignore) |> ignore
 
+[<Test>]
+let ``AsyncSeq.splitAt disposes enumerator when source throws during collection`` () =
+  let mutable disposed = false
+  let source = asyncSeq {
+    use _ = { new System.IDisposable with member _.Dispose() = disposed <- true }
+    yield 1
+    yield 2
+    failwith "source error"
+  }
+  try AsyncSeq.splitAt 10 source |> Async.RunSynchronously |> ignore
+  with _ -> ()
+  Assert.IsTrue(disposed, "enumerator should be disposed after exception during collection")
+
 // ===== removeAt =====
 
 [<Test>]
@@ -4380,6 +4472,20 @@ let ``AsyncSeq.tryTail returns all-but-first elements`` () =
   let tail = result.Value |> AsyncSeq.toListAsync |> Async.RunSynchronously
   Assert.AreEqual([2;3;4;5], tail)
 
+[<Test>]
+let ``AsyncSeq.tryTail disposes enumerator when source throws on first MoveNext`` () =
+  let mutable disposed = false
+  // Use a pre-failed task so the exception occurs during MoveNext() (async), not during GetEnumerator()
+  let failedTask = System.Threading.Tasks.Task.FromException<unit>(System.Exception("source error"))
+  let source = asyncSeq {
+    use _ = { new System.IDisposable with member _.Dispose() = disposed <- true }
+    let! _ = failedTask |> Async.AwaitTask
+    yield 1
+  }
+  try AsyncSeq.tryTail source |> Async.RunSynchronously |> ignore
+  with _ -> ()
+  Assert.IsTrue(disposed, "enumerator should be disposed after exception on first MoveNext")
+
 [<Test>]
 let ``AsyncSeq.where is alias for filter`` () =
   let result =