Implement TaskSeq.removeAt and TaskSeq.removeManyAt

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -317,6 +317,8 @@ type TaskSeq private () =
 
     static member insertAt index value source = Internal.insertAt index (One value) source
     static member insertManyAt index values source = Internal.insertAt index (Many values) source
+    static member removeAt index source = Internal.removeAt index source
+    static member removeManyAt index count source = Internal.removeManyAt index count source
 
     static member except itemsToExclude source = Internal.except itemsToExclude source
     static member exceptOfSeq itemsToExclude source = Internal.exceptOfSeq itemsToExclude source

src/FSharp.Control.TaskSeq/TaskSeq.fsi

@@ -1300,3 +1300,29 @@ type TaskSeq =
     /// <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
     /// <exception cref="T:ArgumentException">Thrown when index is below 0 or greater than source length.</exception>
     static member insertManyAt: index: int -> values: TaskSeq<'T> -> source: TaskSeq<'T> -> TaskSeq<'T>
+
+    /// <summary>
+    /// Return a new task sequence with the item at the given index removed.
+    /// </summary>
+    ///
+    /// <param name="index">The index where the item should be removed.</param>
+    /// <param name="source">The input task sequence.</param>
+    /// <returns>The result task sequence.</returns>
+    /// <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
+    /// <exception cref="T:ArgumentException">Thrown when index is below 0 or greater than source length.</exception>
+    static member removeAt: index: int -> source: TaskSeq<'T> -> TaskSeq<'T>
+
+    /// <summary>
+    /// Return a new task sequence with the number of items starting at a given index removed.
+    /// If <paramref name="count" /> is negative or zero, no items are removed. If <paramref name="index" />
+    /// + <paramref name="count" /> is greater than source length, but <paramref name="index" /> is not, then
+    /// all items until end of sequence are removed.
+    /// </summary>
+    ///
+    /// <param name="index">The index where the items should be removed.</param>
+    /// <param name="count">The number of items to remove.</param>
+    /// <param name="source">The input task sequence.</param>
+    /// <returns>The result task sequence.</returns>
+    /// <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
+    /// <exception cref="T:ArgumentException">Thrown when index is below 0 or greater than source length.</exception>
+    static member removeManyAt: index: int -> count: int -> source: TaskSeq<'T> -> TaskSeq<'T>

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -896,6 +896,43 @@ module internal TaskSeqInternal =
                 raiseOutOfBounds (nameof index)
         }
 
+    let removeAt index (source: TaskSeq<'T>) =
+        if index < 0 then
+            raiseCannotBeNegative (nameof index)
+
+        taskSeq {
+            let mutable i = 0
+
+            for item in source do
+                if i <> index then
+                    yield item
+
+                i <- i + 1
+
+            // cannot remove past end of sequence
+            if i <= index then
+                raiseOutOfBounds (nameof index)
+        }
+
+    let removeManyAt index count (source: TaskSeq<'T>) =
+        if index < 0 then
+            raiseCannotBeNegative (nameof index)
+
+        taskSeq {
+            let mutable i = 0
+            let indexEnd = index + count
+
+            for item in source do
+                if i < index || i >= indexEnd then
+                    yield item
+
+                i <- i + 1
+
+            // cannot remove past end of sequence
+            if i <= index then
+                raiseOutOfBounds (nameof index)
+        }
+
     // Consider turning using an F# version of this instead?
     // https://github.com/i3arnon/ConcurrentHashSet
     type ConcurrentHashSet<'T when 'T: equality>(ct) =