add seq.zipWithIndex

src/List.ts

@@ -245,6 +245,17 @@ export abstract class List<T> implements Iterable<T>, Seq<T> {
      */
     abstract zip<U>(other: Iterable<U>): List<[T,U]>;
 
+    /**
+     * Combine this collection with the index of the elements
+     * in it. Handy if you need the index when you map on
+     * the collection for instance:
+     *
+     *     List.of("a","b").zipWithIndex().map([v,idx] => ...)
+     */
+    zipWithIndex(): List<[T,number]> {
+        return <List<[T,number]>>SeqHelpers.zipWithIndex<T>(this);
+    }
+
     /**
      * Reverse the collection. For instance:
      *
@@ -288,7 +299,7 @@ export abstract class List<T> implements Iterable<T>, Seq<T> {
      * Randomly reorder the elements of the collection.
      */
     shuffle(): List<T> {
-        return List.ofIterable(SeqHelpers.shuffle(this.toArray()));
+        return List.ofIterable<T>(SeqHelpers.shuffle(this.toArray()));
     }
 
     /**

src/Seq.ts

@@ -154,6 +154,15 @@ export interface Seq<T> extends Collection<T>, Foldable<T> {
      */
     zip<U>(other: Iterable<U>): Seq<[T,U]>;
 
+    /**
+     * Combine this collection with the index of the elements
+     * in it. Handy if you need the index when you map on
+     * the collection for instance:
+     *
+     *     Vector.of("a","b").zipWithIndex().map([v,idx] => ...)
+     */
+    zipWithIndex(): Seq<[T,number]>;
+
     /**
      * Retrieve the element at index idx.
      * Returns an option because the collection may

src/SeqHelpers.ts

@@ -2,6 +2,7 @@ import { Option } from "./Option";
 import { WithEquality, hasTrueEquality } from "./Comparison";
 import { IMap } from "./IMap";
 import { Seq } from "./Seq";
+import { Stream } from "./Stream";
 
 /**
  * @hidden
@@ -41,3 +42,10 @@ export function arrangeBy<T,K>(seq: Seq<T>, getKey: (v:T)=>K&WithEquality): Opti
 export function seqHasTrueEquality<T>(seq: Seq<T>): boolean {
     return seq.find(x => x!=null).hasTrueEquality();
 }
+
+/**
+ * @hidden
+ */
+export function zipWithIndex<T>(seq: Seq<T>): Seq<[T,number]> {
+    return seq.zip<number>(Stream.iterate(0,i=>i+1));
+}

src/Stream.ts

@@ -275,6 +275,17 @@ export abstract class Stream<T> implements Iterable<T>, Seq<T> {
      */
     abstract zip<U>(other: Iterable<U>): Stream<[T,U]>;
 
+    /**
+     * Combine this collection with the index of the elements
+     * in it. Handy if you need the index when you map on
+     * the collection for instance:
+     *
+     *     Stream.of("a","b").zipWithIndex().map([v,idx] => ...)
+     */
+    zipWithIndex(): Stream<[T,number]> {
+        return <Stream<[T,number]>>SeqHelpers.zipWithIndex<T>(this);
+    }
+
     /**
      * Reverse the collection. For instance:
      *

src/Vector.ts

@@ -631,6 +631,17 @@ export class Vector<T> implements Seq<T>, Iterable<T> {
             }), 0);
     }
 
+    /**
+     * Combine this collection with the index of the elements
+     * in it. Handy if you need the index when you map on
+     * the collection for instance:
+     *
+     *     Vector.of("a","b").zipWithIndex().map([v,idx] => ...)
+     */
+    zipWithIndex(): Vector<[T,number]> {
+        return <Vector<[T,number]>>SeqHelpers.zipWithIndex<T>(this);
+    }
+
     /**
      * Reverse the collection. For instance:
      *