Add AsyncSeq.splitAt — splits at index, returning first N elements as array and remainder as AsyncSeq

Mirrors Seq.splitAt. Source is enumerated once; remainder is produced lazily.
6 new tests; 293/293 total pass.

Co-authored-by: Copilot <[email protected]>

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 4.7.0
+
+* Added `AsyncSeq.splitAt` — splits a sequence at the given index, returning the first `count` elements as an array and the remaining elements as a new `AsyncSeq`. Mirrors `Seq.splitAt`. The source is enumerated once.
+
 ### 4.6.0
 
 * Added `AsyncSeq.isEmpty` — returns `true` if the sequence contains no elements; short-circuits after the first element, mirroring `Seq.isEmpty`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1815,6 +1815,35 @@ module AsyncSeq =
 
   let tail (source : AsyncSeq<'T>) : AsyncSeq<'T> = skip 1 source
 
+  /// 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 b = ref m
+      while b.Value.IsSome && ra.Count < count do
+          ra.Add b.Value.Value
+          let! next = ie.MoveNext()
+          b := next
+      let first = ra.ToArray()
+      let rest =
+          if b.Value.IsNone then
+              ie.Dispose()
+              empty<'T>
+          else
+              let cur = ref b.Value
+              asyncSeq {
+                  try
+                      while cur.Value.IsSome do
+                          yield cur.Value.Value
+                          let! next = ie.MoveNext()
+                          cur := next
+                  finally
+                      ie.Dispose() }
+      return first, rest }
+
   let toArrayAsync (source : AsyncSeq<'T>) : Async<'T[]> = async {
       let ra = (new ResizeArray<_>())
       use ie = source.GetEnumerator()

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -586,6 +586,11 @@ module AsyncSeq =
     /// Returns an empty sequence if the source is empty.
     val tail : source:AsyncSeq<'T> -> AsyncSeq<'T>
 
+    /// Splits an async sequence at the given index. Returns an async computation that yields
+    /// the first `count` elements as an array and the remaining elements as a new AsyncSeq.
+    /// The source is enumerated once; the returned AsyncSeq lazily produces the remainder.
+    val splitAt : count:int -> source:AsyncSeq<'T> -> Async<'T array * AsyncSeq<'T>>
+
     /// Creates an async computation which iterates the AsyncSeq and collects the output into an array.
     val toArrayAsync : source:AsyncSeq<'T> -> Async<'T []>
 

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

@@ -3408,3 +3408,47 @@ let ``AsyncSeq.sortWith sorts descending with negated comparer`` () =
 let ``AsyncSeq.sortWith returns empty array for empty sequence`` () =
   let result = AsyncSeq.sortWith compare AsyncSeq.empty<int>
   Assert.AreEqual([||], result)
+
+[<Test>]
+let ``AsyncSeq.splitAt splits a sequence at the given index`` () =
+  let source = asyncSeq { yield 1; yield 2; yield 3; yield 4; yield 5 }
+  let first, rest = AsyncSeq.splitAt 3 source |> Async.RunSynchronously
+  let restArr = rest |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3 |], first)
+  Assert.AreEqual([| 4; 5 |], restArr)
+
+[<Test>]
+let ``AsyncSeq.splitAt with count=0 returns empty array and full rest`` () =
+  let source = asyncSeq { yield 10; yield 20 }
+  let first, rest = AsyncSeq.splitAt 0 source |> Async.RunSynchronously
+  let restArr = rest |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([||], first)
+  Assert.AreEqual([| 10; 20 |], restArr)
+
+[<Test>]
+let ``AsyncSeq.splitAt with count >= length returns all elements in first and empty rest`` () =
+  let source = asyncSeq { yield 1; yield 2; yield 3 }
+  let first, rest = AsyncSeq.splitAt 10 source |> Async.RunSynchronously
+  let restArr = rest |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3 |], first)
+  Assert.AreEqual([||], restArr)
+
+[<Test>]
+let ``AsyncSeq.splitAt on empty sequence returns empty first and empty rest`` () =
+  let first, rest = AsyncSeq.splitAt 3 AsyncSeq.empty<int> |> Async.RunSynchronously
+  let restArr = rest |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([||], first)
+  Assert.AreEqual([||], restArr)
+
+[<Test>]
+let ``AsyncSeq.splitAt with count equal to length returns all in first and empty rest`` () =
+  let source = asyncSeq { yield 7; yield 8; yield 9 }
+  let first, rest = AsyncSeq.splitAt 3 source |> Async.RunSynchronously
+  let restArr = rest |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 7; 8; 9 |], first)
+  Assert.AreEqual([||], restArr)
+
+[<Test>]
+let ``AsyncSeq.splitAt with negative count throws ArgumentException`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.splitAt -1 AsyncSeq.empty<int> |> Async.RunSynchronously |> ignore) |> ignore