immutable-js · leebyron · Sep 18, 2018 · Sep 8, 2018
diff --git a/__tests__/IterableSeq.ts b/__tests__/IterableSeq.ts
diff --git a/__tests__/Seq.ts b/__tests__/Seq.ts
@@ -22,6 +22,10 @@ describe('Seq', () => {
    expect(Seq({ a: 1, b: 2, c: 3 }).size).toBe(3);
  });

+  it('accepts an object with a next property', () => {
+    expect(Seq({ a: 1, b: 2, next: _ => _ }).size).toBe(3);
+  });
+
  it('accepts a collection string', () => {
    expect(Seq('foo').size).toBe(3);
  });

diff --git a/src/Seq.js b/src/Seq.js
@@ -288,55 +288,6 @@ class CollectionSeq extends IndexedSeq {
  }
 }

-class IteratorSeq extends IndexedSeq {
-  constructor(iterator) {
-    this._iterator = iterator;
-    this._iteratorCache = [];
-  }
-
-  __iterateUncached(fn, reverse) {
-    if (reverse) {
-      return this.cacheResult().__iterate(fn, reverse);
-    }
-    const iterator = this._iterator;
-    const cache = this._iteratorCache;
-    let iterations = 0;
-    while (iterations < cache.length) {
-      if (fn(cache[iterations], iterations++, this) === false) {
-        return iterations;
-      }
-    }
-    let step;
-    while (!(step = iterator.next()).done) {
-      const val = step.value;
-      cache[iterations] = val;
-      if (fn(val, iterations++, this) === false) {
-        break;
-      }
-    }
-    return iterations;
-  }
-
-  __iteratorUncached(type, reverse) {
-    if (reverse) {
-      return this.cacheResult().__iterator(type, reverse);
-    }
-    const iterator = this._iterator;
-    const cache = this._iteratorCache;
-    let iterations = 0;
-    return new Iterator(() => {
-      if (iterations >= cache.length) {
-        const step = iterator.next();
-        if (step.done) {
-          return step;
-        }
-        cache[iterations] = step.value;
-      }
-      return iteratorValue(type, iterations, cache[iterations++]);
-    });
-  }
-}
-
 // # pragma Helper functions

 export function isSeq(maybeSeq) {
@@ -352,11 +303,9 @@ function emptySequence() {
 export function keyedSeqFromValue(value) {
  const seq = Array.isArray(value)
    ? new ArraySeq(value)
-    : isIterator(value)
-      ? new IteratorSeq(value)
-      : hasIterator(value)
-        ? new CollectionSeq(value)
-        : undefined;
+    : hasIterator(value)
+      ? new CollectionSeq(value)
+      : undefined;
  if (seq) {
    return seq.fromEntrySeq();
  }
@@ -395,9 +344,7 @@ function seqFromValue(value) {
 function maybeIndexedSeqFromValue(value) {
  return isArrayLike(value)
    ? new ArraySeq(value)
-    : isIterator(value)
-      ? new IteratorSeq(value)
-      : hasIterator(value)
-        ? new CollectionSeq(value)
-        : undefined;
+    : hasIterator(value)
+      ? new CollectionSeq(value)
+      : undefined;
 }
diff --git a/type-definitions/Immutable.d.ts b/type-definitions/Immutable.d.ts
@@ -3008,10 +3008,13 @@ declare module Immutable {
   *   * If a `Seq`, that same `Seq`.
   *   * If an `Collection`, a `Seq` of the same kind (Keyed, Indexed, or Set).
   *   * If an Array-like, an `Seq.Indexed`.
-   *   * If an Object with an Iterator, an `Seq.Indexed`.
-   *   * If an Iterator, an `Seq.Indexed`.
+   *   * If an Iterable Object, an `Seq.Indexed`.
   *   * If an Object, a `Seq.Keyed`.
   *
+   * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`,
+   * which is usually not what you want. You should turn your Iterator Object into
+   * an iterable object by defining a Symbol.iterator (or @@iterator) method which
+   * returns `this`.
   */
  export function Seq<S extends Seq<any, any>>(seq: S): S;
  export function Seq<K, V>(collection: Collection.Keyed<K, V>): Seq.Keyed<K, V>;
@@ -3723,13 +3726,17 @@ declare module Immutable {
   *
   *   * If an `Collection`, that same `Collection`.
   *   * If an Array-like, an `Collection.Indexed`.
-   *   * If an Object with an Iterator, an `Collection.Indexed`.
-   *   * If an Iterator, an `Collection.Indexed`.
+   *   * If an Object with an Iterator defined, an `Collection.Indexed`.
   *   * If an Object, an `Collection.Keyed`.
   *
   * This methods forces the conversion of Objects and Strings to Collections.
   * If you want to ensure that a Collection of one item is returned, use
   * `Seq.of`.
+   *
+   * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`,
+   * which is usually not what you want. You should turn your Iterator Object into
+   * an iterable object by defining a Symbol.iterator (or @@iterator) method which
+   * returns `this`.
   */
  export function Collection<I extends Collection<any, any>>(collection: I): I;
  export function Collection<T>(collection: Iterable<T>): Collection.Indexed<T>;