immutable-js · conartist6 · Oct 30, 2018
diff --git a/__tests__/List.ts b/__tests__/List.ts
@@ -660,17 +660,30 @@ describe('List', () => {
     expect(a).toEqual([0, 1, 2, 3, 4]);
   });
 
-  it('forEach iteration terminates when callback returns false', () => {
+  it('forSome iteration terminates when callback returns false', () => {
     const a: Array<any> = [];
     function count(x) {
-      if (x > 2) {
+      a.push(x);
+      if (x >= 2) {
         return false;
       }
+    }
+    const v = List.of(0, 1, 2, 3, 4);
+    v.forSome(count);
+    expect(a).toEqual([0, 1, 2]);
+  });
+
+  it('forEach iteration does not terminate when callback returns false', () => {
+    const a: Array<any> = [];
+    function count(x) {
       a.push(x);
+      if (x > 2) {
+        return false;
+      }
     }
     const v = List.of(0, 1, 2, 3, 4);
     v.forEach(count);
-    expect(a).toEqual([0, 1, 2]);
+    expect(a).toEqual([0, 1, 2, 3, 4]);
   });
 
   it('concat works like Array.prototype.concat', () => {

diff --git a/__tests__/flatten.ts b/__tests__/flatten.ts
@@ -28,7 +28,7 @@ describe('flatten', () => {
   it('gives the correct iteration count', () => {
     const nested = fromJS([[1, 2, 3], [4, 5, 6]]);
     const flat = nested.flatten();
-    expect(flat.forEach(x => x < 4)).toEqual(4);
+    expect(flat.forSome(x => x < 4)).toEqual(4);
   });
 
   type SeqType = number | Array<number> | Collection<number, number>;

diff --git a/src/CollectionImpl.js b/src/CollectionImpl.js
@@ -222,6 +222,13 @@ mixin(Collection, {
   },
 
   forEach(sideEffect, context) {
+    assertNotInfinite(this.size);
+    this.__iterate((...args) => {
+      sideEffect.apply(context, args);
+    });
+  },
+
+  forSome(sideEffect, context) {
     assertNotInfinite(this.size);
     return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
   },

diff --git a/type-definitions/Immutable.d.ts b/type-definitions/Immutable.d.ts
@@ -4294,14 +4294,22 @@ declare module Immutable {
 
     // Side effects
 
+    /**
+     * The `sideEffect` is executed for every entry in the Collection.
+     */
+    forEach(
+      sideEffect: (value: V, key: K, iter: this) => any,
+      context?: any
+    ): this;
+
     /**
      * The `sideEffect` is executed for every entry in the Collection.
      *
-     * Unlike `Array#forEach`, if any call of `sideEffect` returns
+     * Unlike `#forEach`, if any call of `sideEffect` returns
      * `false`, the iteration will stop. Returns the number of entries iterated
      * (including the last iteration which returned false).
      */
-    forEach(
+    forSome(
       sideEffect: (value: V, key: K, iter: this) => any,
       context?: any
     ): number;

diff --git a/type-definitions/immutable.js.flow b/type-definitions/immutable.js.flow
@@ -116,6 +116,11 @@ declare class _Collection<K, +V> implements ValueObject {
   forEach(
     sideEffect: (value: V, key: K, iter: this) => any,
     context?: mixed
+  ): this;
+
+  forSome(
+    sideEffect: (value: V, key: K, iter: this) => any,
+    context?: mixed
   ): number;
 
   slice(begin?: number, end?: number): this;