Merge branch 'main' into repo-assist/improve-new-combinators-87b33ebcb712bf81

Author: dsyme

.github/aw/actions-lock.json

@@ -10,10 +10,10 @@
       "version": "v8",
       "sha": "ed597411d8f924073f98dfc5c65a23a2325f34cd"
     },
-    "github/gh-aw/actions/setup@v0.52.1": {
+    "github/gh-aw/actions/setup@v0.53.6": {
       "repo": "github/gh-aw/actions/setup",
-      "version": "v0.52.1",
-      "sha": "a86e657586e4ac5f549a790628971ec02f6a4a8f"
+      "version": "v0.53.6",
+      "sha": "956f874e40e831c08a8b01ec76f5d49ae3fe8387"
     }
   }
 }

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

@@ -4,6 +4,10 @@
 * Added `AsyncSeq.mapFold` — synchronous variant of `AsyncSeq.mapFoldAsync`, mirroring `Seq.mapFold`.
 * Added `AsyncSeq.allPairs` — returns an async sequence of all pairs from two input sequences (cartesian product); the second source is fully buffered before iteration, mirroring `Seq.allPairs`.
 * Added `AsyncSeq.rev` — returns a new async sequence with all elements in reverse order; the entire source sequence is buffered before yielding, mirroring `Seq.rev`.
+* 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.
+* Added `AsyncSeq.removeAt` — returns a new sequence with the element at the specified index removed, mirroring `Seq.removeAt`.
+* Added `AsyncSeq.updateAt` — returns a new sequence with the element at the specified index replaced by a given value, mirroring `Seq.updateAt`.
+* Added `AsyncSeq.insertAt` — returns a new sequence with a value inserted before the element at the specified index (or appended if the index equals the sequence length), mirroring `Seq.insertAt`.
 
 ### 4.6.0
 

.github/workflows/repo-assist.md

@@ -1449,6 +1449,32 @@ module AsyncSeq =
     let s = System.Collections.Generic.HashSet(excluded)
     source |> filter (fun x -> not (s.Contains(x)))
 
+  let removeAt (index : int) (source : AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
+    if index < 0 then invalidArg "index" "must be non-negative"
+    let i = ref 0
+    for x in source do
+      if i.Value <> index then yield x
+      i := i.Value + 1 }
+
+  let updateAt (index : int) (value : 'T) (source : AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
+    if index < 0 then invalidArg "index" "must be non-negative"
+    let i = ref 0
+    for x in source do
+      if i.Value = index then yield value
+      else yield x
+      i := i.Value + 1 }
+
+  let insertAt (index : int) (value : 'T) (source : AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
+    if index < 0 then invalidArg "index" "must be non-negative"
+    let i = ref 0
+    for x in source do
+      if i.Value = index then yield value
+      yield x
+      i := i.Value + 1
+    if i.Value = index then yield value
+    elif i.Value < index then
+      invalidArg "index" "The index is outside the range of elements in the collection." }
+
   #if !FABLE_COMPILER
   let iterAsyncParallel (f:'a -> Async<unit>) (s:AsyncSeq<'a>) : Async<unit> = async {
     use mb = MailboxProcessor.Start (ignore >> async.Return)
@@ -1851,6 +1877,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()

RELEASE_NOTES.md

@@ -418,6 +418,19 @@ module AsyncSeq =
     /// in the given excluded collection. Uses a HashSet for O(1) lookup. Mirrors Seq.except.
     val except : excluded:seq<'T> -> source:AsyncSeq<'T> -> AsyncSeq<'T> when 'T : equality
 
+    /// Returns a new asynchronous sequence with the element at the specified index removed.
+    /// Raises ArgumentException if index is negative. Mirrors Seq.removeAt.
+    val removeAt : index:int -> source:AsyncSeq<'T> -> AsyncSeq<'T>
+
+    /// Returns a new asynchronous sequence with the element at the specified index replaced by the given value.
+    /// Raises ArgumentException if index is negative. Mirrors Seq.updateAt.
+    val updateAt : index:int -> value:'T -> source:AsyncSeq<'T> -> AsyncSeq<'T>
+
+    /// Returns a new asynchronous sequence with the given value inserted before the element at the specified index.
+    /// An index equal to the length of the sequence appends the value at the end.
+    /// Raises ArgumentException if index is negative or greater than the sequence length. Mirrors Seq.insertAt.
+    val insertAt : index:int -> value:'T -> source:AsyncSeq<'T> -> AsyncSeq<'T>
+
     /// Creates an asynchronous sequence that lazily takes element from an
     /// input synchronous sequence and returns them one-by-one.
     val ofSeq : source:seq<'T> -> AsyncSeq<'T>
@@ -600,6 +613,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 []>
 

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -3486,3 +3486,179 @@ let ``AsyncSeq.rev returns empty sequence for empty input`` () =
 let ``AsyncSeq.rev returns singleton for single element`` () =
   let result = AsyncSeq.rev (asyncSeq { yield 42 }) |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
   Assert.AreEqual([| 42 |], 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
+
+// ===== removeAt =====
+
+[<Test>]
+let ``AsyncSeq.removeAt removes the element at the specified index`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3; 4; 5 ]
+    |> AsyncSeq.removeAt 2
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 4; 5 |], result)
+
+[<Test>]
+let ``AsyncSeq.removeAt removes the first element (index 0)`` () =
+  let result =
+    AsyncSeq.ofSeq [ 10; 20; 30 ]
+    |> AsyncSeq.removeAt 0
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 20; 30 |], result)
+
+[<Test>]
+let ``AsyncSeq.removeAt removes the last element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.removeAt 2
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2 |], result)
+
+[<Test>]
+let ``AsyncSeq.removeAt raises ArgumentException for negative index`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.removeAt -1
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+// ===== updateAt =====
+
+[<Test>]
+let ``AsyncSeq.updateAt replaces element at specified index`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3; 4 ]
+    |> AsyncSeq.updateAt 1 99
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 99; 3; 4 |], result)
+
+[<Test>]
+let ``AsyncSeq.updateAt replaces first element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.updateAt 0 99
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 99; 2; 3 |], result)
+
+[<Test>]
+let ``AsyncSeq.updateAt replaces last element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.updateAt 2 99
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 99 |], result)
+
+[<Test>]
+let ``AsyncSeq.updateAt raises ArgumentException for negative index`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.updateAt -1 0
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+// ===== insertAt =====
+
+[<Test>]
+let ``AsyncSeq.insertAt inserts element at specified index`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 4; 5 ]
+    |> AsyncSeq.insertAt 2 3
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3; 4; 5 |], result)
+
+[<Test>]
+let ``AsyncSeq.insertAt inserts at index 0 (prepend)`` () =
+  let result =
+    AsyncSeq.ofSeq [ 2; 3 ]
+    |> AsyncSeq.insertAt 0 1
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3 |], result)
+
+[<Test>]
+let ``AsyncSeq.insertAt appends when index equals sequence length`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.insertAt 3 4
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 2; 3; 4 |], result)
+
+[<Test>]
+let ``AsyncSeq.insertAt inserts into empty sequence at index 0`` () =
+  let result =
+    AsyncSeq.empty<int>
+    |> AsyncSeq.insertAt 0 42
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 42 |], result)
+
+[<Test>]
+let ``AsyncSeq.insertAt raises ArgumentException for negative index`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.insertAt -1 0
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.insertAt raises ArgumentException when index exceeds length`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.insertAt 5 0
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>4.6.0</Version>
+    <Version>4.7.0</Version>
   </PropertyGroup>
 </Project>