Implement TaskSeq.indexed + tests & docs

Author: abelbraaksma

src/FSharpy.TaskSeq.Test/FSharpy.TaskSeq.Test.fsproj

@@ -21,6 +21,7 @@
     <Compile Include="TaskSeq.Find.Tests.fs" />
     <Compile Include="TaskSeq.Fold.Tests.fs" />
     <Compile Include="TaskSeq.Head.Tests.fs" />
+    <Compile Include="TaskSeq.Indexed.Tests.fs" />
     <Compile Include="TaskSeq.IsEmpty.fs" />
     <Compile Include="TaskSeq.Item.Tests.fs" />
     <Compile Include="TaskSeq.Iter.Tests.fs" />

src/FSharpy.TaskSeq.Test/TaskSeq.Indexed.Tests.fs

@@ -0,0 +1,34 @@
+module FSharpy.Tests.Indexed
+
+open Xunit
+open FsUnit.Xunit
+open FsToolkit.ErrorHandling
+
+open FSharpy
+
+//
+// TaskSeq.indexed
+//
+
+module EmptySeq =
+    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
+    let ``TaskSeq-indexed on empty`` variant =
+        Gen.getEmptyVariant variant
+        |> TaskSeq.indexed
+        |> verifyEmpty
+
+module Immutable =
+    [<Fact>]
+    let ``TaskSeq-indexed starts at zero`` () =
+        taskSeq { yield 99 }
+        |> TaskSeq.indexed
+        |> TaskSeq.head
+        |> Task.map (should equal (0, 99))
+
+    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
+    let ``TaskSeq-indexed`` variant =
+        Gen.getSeqImmutable variant
+        |> TaskSeq.indexed
+        |> TaskSeq.toArrayAsync
+        |> Task.map (Array.forall (fun (x, y) -> x + 1 = y))
+        |> Task.map (should be True)

src/FSharpy.TaskSeq/TaskSeq.fs

@@ -165,7 +165,10 @@ module TaskSeq =
 
     let cast source : taskSeq<'T> = Internal.map (SimpleAction(fun (x: obj) -> x :?> 'T)) source
     let box source = Internal.map (SimpleAction(fun x -> box x)) source
-    let unbox<'U when 'U: struct> (source: taskSeq<obj>) : taskSeq<'U> = Internal.map (SimpleAction(fun x -> unbox x)) source
+
+    let unbox<'U when 'U: struct> (source: taskSeq<obj>) : taskSeq<'U> =
+        Internal.map (SimpleAction(fun x -> unbox x)) source
+
     let iter action source = Internal.iter (SimpleAction action) source
     let iteri action source = Internal.iter (CountableAction action) source
     let iterAsync action source = Internal.iter (AsyncSimpleAction action) source
@@ -222,6 +225,14 @@ module TaskSeq =
         | None -> return invalidArg (nameof source) "The input sequence contains more than one element."
     }
 
+    let indexed (source: taskSeq<'T>) = taskSeq {
+        let mutable i = 0
+
+        for x in source do
+            yield i, x
+            i <- i + 1
+    }
+
     let choose chooser source = Internal.choose (TryPick chooser) source
     let chooseAsync chooser source = Internal.choose (TryPickAsync chooser) source
     let filter predicate source = Internal.filter (Predicate predicate) source

src/FSharpy.TaskSeq/TaskSeq.fsi

@@ -125,6 +125,16 @@ module TaskSeq =
     /// Maps over the taskSeq, applying the mapper function to each item. This function is non-blocking.
     val map: mapper: ('T -> 'U) -> source: taskSeq<'T> -> taskSeq<'U>
 
+    /// <summary>
+    /// Builds a new task sequence whose elements are the corresponding elements of the input task
+    /// sequence <paramref name="source" /> paired with the integer index (from 0) of each element.
+    /// Does not evaluate the input sequence until requested.
+    /// </summary>
+    /// <param name="source">The input task sequence.</param>
+    /// <returns>The resulting task sequence of tuples.</returns>
+    /// <exception cref="T:ArgumentNullException">Thrown when the input sequence is null.</exception>
+    val indexed: source: taskSeq<'T> -> taskSeq<int * 'T>
+
     /// Maps over the taskSeq with an index, applying the mapper function to each item. This function is non-blocking.
     val mapi: mapper: (int -> 'T -> 'U) -> source: taskSeq<'T> -> taskSeq<'U>