Implement TaskSeq.updateAt

Author: abelbraaksma

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -319,6 +319,7 @@ type TaskSeq private () =
     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 updateAt index value source = Internal.updateAt index value 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

@@ -1326,3 +1326,15 @@ 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 removeManyAt: index: int -> count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
+
+    /// <summary>
+    /// Return a new task sequence with the item at a given index set to the new value.
+    /// </summary>
+    ///
+    /// <param name="index">The index of the item to be replaced.</param>
+    /// <param name="value">The new value.</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 updateAt: index: int -> value: 'T -> source: TaskSeq<'T> -> TaskSeq<'T>

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -933,6 +933,26 @@ module internal TaskSeqInternal =
                 raiseOutOfBounds (nameof index)
         }
 
+    let updateAt index value (source: TaskSeq<'T>) =
+        if index < 0 then
+            raiseCannotBeNegative (nameof index)
+
+        taskSeq {
+            let mutable i = 0
+
+            for item in source do
+                if i <> index then // most common scenario on top (cpu prediction)
+                    yield item
+                else
+                    yield value
+
+                i <- i + 1
+
+            // cannot update 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) =