Merge branch 'main' into repo-assist/improve-splitat-cc1b1026bf3ab37b

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

@@ -1,6 +1,9 @@
 ### 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.
+* 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

@@ -1432,6 +1432,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)

RELEASE_NOTES.md

@@ -408,6 +408,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>

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -3452,3 +3452,135 @@ let ``AsyncSeq.splitAt with count equal to length returns all in first and empty
 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>