Add TaskSeq.insertAt and TaskSeq.insertManyAt

Author: abelbraaksma

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -315,6 +315,9 @@ type TaskSeq private () =
     static member tryFindIndex predicate source = Internal.tryFindIndex (Predicate predicate) source
     static member tryFindIndexAsync predicate source = Internal.tryFindIndex (PredicateAsync predicate) source
 
+    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 except itemsToExclude source = Internal.except itemsToExclude source
     static member exceptOfSeq itemsToExclude source = Internal.exceptOfSeq itemsToExclude source
 

src/FSharp.Control.TaskSeq/TaskSeq.fsi

@@ -1241,6 +1241,7 @@ type TaskSeq =
     ///
     /// <param name="source1">The first input task sequence.</param>
     /// <param name="source2">The second input task sequence.</param>
+    /// <returns>The result task sequence of tuples.</returns>
     /// <exception cref="T:ArgumentNullException">Thrown when either of the two input task sequences is null.</exception>
     static member zip: source1: TaskSeq<'T> -> source2: TaskSeq<'U> -> TaskSeq<'T * 'U>
 
@@ -1275,3 +1276,27 @@ type TaskSeq =
     /// <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
     static member foldAsync:
         folder: ('State -> 'T -> #Task<'State>) -> state: 'State -> source: TaskSeq<'T> -> Task<'State>
+
+    /// <summary>
+    /// Return a new task sequence with a new item inserted before the given index.
+    /// </summary>
+    ///
+    /// <param name="index">The index where the item should be inserted.</param>
+    /// <param name="value">The value to insert.</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 insertAt: index: int -> value: 'T -> source: TaskSeq<'T> -> TaskSeq<'T>
+
+    /// <summary>
+    /// Return a new task sequence with the new items inserted before the given index.
+    /// </summary>
+    ///
+    /// <param name="index">The index where the items should be inserted.</param>
+    /// <param name="value">The values to insert.</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 insertManyAt: index: int -> values: TaskSeq<'T> -> source: TaskSeq<'T> -> TaskSeq<'T>

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -49,6 +49,11 @@ type internal InitAction<'T, 'TaskT when 'TaskT :> Task<'T>> =
     | InitAction of init_item: (int -> 'T)
     | InitActionAsync of async_init_item: (int -> 'TaskT)
 
+[<Struct>]
+type internal ManyOrOne<'T> =
+    | Many of source_seq: TaskSeq<'T>
+    | One of source_item: 'T
+
 module internal TaskSeqInternal =
     /// Raise an NRE for arguments that are null. Only used for 'source' parameters, never for function parameters.
     let inline checkNonNull argName arg =
@@ -861,6 +866,33 @@ module internal TaskSeqInternal =
                 yield e.Current
         }
 
+    /// InsertAt or InsertManyAt
+    let insertAt index valueOrValues (source: TaskSeq<_>) =
+        if index < 0 then
+            invalidArg "index" "index cannot be negative."
+
+        taskSeq {
+            let mutable i = 0
+
+            for item in source do
+                if i = index then
+                    match valueOrValues with
+                    | Many values -> yield! values
+                    | One value -> yield value
+
+                yield item
+                i <- i + 1
+
+            // allow inserting at the end
+            if i = index then
+                match valueOrValues with
+                | Many values -> yield! values
+                | One value -> yield value
+
+            if i < index then
+                invalidArg "index" "index must be within the bounds of the task sequence."
+        }
+
     // Consider turning using an F# version of this instead?
     // https://github.com/i3arnon/ConcurrentHashSet
     type ConcurrentHashSet<'T when 'T: equality>(ct) =