Fix: removeAt and updateAt now raise ArgumentException for out-of-range index

AsyncSeq.removeAt and AsyncSeq.updateAt previously silently returned the
source sequence unchanged when the index was >= the sequence length, which
is inconsistent with List.removeAt, Array.removeAt, and AsyncSeq.insertAt.

After the enumeration loop, check that the index was actually reached; if
not (i.e. i <= index at end), raise ArgumentException matching the message
used by AsyncSeq.insertAt.

Adds 6 new tests covering out-of-range and boundary indices.

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

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 4.15.0
+
+* Bug fix: `AsyncSeq.removeAt` and `AsyncSeq.updateAt` now raise `ArgumentException` when the index is greater than or equal to the sequence length, consistent with `List.removeAt`, `Array.removeAt`, and `AsyncSeq.insertAt`. Previously they silently returned the sequence unchanged.
+
 ### 4.14.0
 
 * Added `AsyncSeq.mapAsyncParallelThrottled` — ordered, bounded-concurrency parallel map. Like `mapAsyncParallel` but limits the number of in-flight operations to `parallelism`, preventing unbounded resource use on large or infinite sequences.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1706,15 +1706,19 @@ module AsyncSeq =
     let mutable i = 0
     for x in source do
       if i <> index then yield x
-      i <- i + 1 }
+      i <- i + 1
+    if i <= index then
+      invalidArg "index" "The index is outside the range of elements in the collection." }
 
   let updateAt (index : int) (value : 'T) (source : AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
     if index < 0 then invalidArg "index" "must be non-negative"
     let mutable i = 0
     for x in source do
       if i = index then yield value
       else yield x
-      i <- i + 1 }
+      i <- i + 1
+    if i <= index then
+      invalidArg "index" "The index is outside the range of elements in the collection." }
 
   let insertAt (index : int) (value : 'T) (source : AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
     if index < 0 then invalidArg "index" "must be non-negative"

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

@@ -3784,6 +3784,24 @@ let ``AsyncSeq.removeAt raises ArgumentException for negative index`` () =
     |> Async.RunSynchronously |> ignore)
   |> ignore
 
+[<Test>]
+let ``AsyncSeq.removeAt raises ArgumentException when index is out of range`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.removeAt 10
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.removeAt raises ArgumentException when index equals sequence length`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.removeAt 3
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
 // ===== updateAt =====
 
 [<Test>]
@@ -3822,6 +3840,24 @@ let ``AsyncSeq.updateAt raises ArgumentException for negative index`` () =
     |> Async.RunSynchronously |> ignore)
   |> ignore
 
+[<Test>]
+let ``AsyncSeq.updateAt raises ArgumentException when index is out of range`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.updateAt 10 99
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.updateAt raises ArgumentException when index equals sequence length`` () =
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.updateAt 3 99
+    |> AsyncSeq.toArrayAsync
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
 // ===== insertAt =====
 
 [<Test>]

version.props

@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>4.14.0</Version>
+    <Version>4.15.0</Version>
   </PropertyGroup>
 </Project>