add mapKeys

__tests__/Map.ts

@@ -131,6 +131,12 @@ describe('Map', () => {
     expect(r.toObject()).toEqual({a:'A', b:'B', c:'C'});
   });
 
+  it('maps keys', () => {
+    var m = Map({a:'a', b:'b', c:'c'});
+    var r = m.mapKeys(value => value.toUpperCase());
+    expect(r.toObject()).toEqual({A:'a', B:'b', C:'c'});
+  });
+
   it('filters values', () => {
     var m = Map({a:1, b:2, c:3, d:4, e:5, f:6});
     var r = m.filter(value => value % 2 === 1);

dist/Immutable.d.ts

@@ -414,24 +414,30 @@ export interface Sequence<K, V> {
   /**
    * Returns a new sequence with values passed through a `mapper` function.
    *
-   *     Sequence({a:1,b:2}).map(x => 10 * x) // { a: 10, b: 20 }
-   *
-   * Note: if you want to map keys instead of values, consider flipping the
-   * Sequence before mapping:
-   *
-   *     Sequence({a:1,b:2}).flip().map(x => x.toUpperCase()).flip() // { A: 1, B: 2 }
+   *     Sequence({ a: 1, b: 2 }).map(x => 10 * x) // { a: 10, b: 20 }
    *
    */
   map<M>(
     mapper: (value?: V, key?: K, seq?: Sequence<K, V>) => M,
     thisArg?: any
   ): Sequence<K, M>;
 
+  /**
+   * Returns a new sequence with keys passed through a `mapper` function.
+   *
+   *     Sequence({ a: 1, b: 2 }).map(x => x.toUpperCase()) // { A: 1, B: 2 }
+   *
+   */
+  mapKeys<M>(
+    mapper: (value?: V, key?: K, seq?: Sequence<K, V>) => M,
+    thisArg?: any
+  ): Sequence<M, V>;
+
   /**
    * Returns a new sequence with only the entries for which the `predicate`
    * function returns true.
    *
-   *     Sequence({a:1,b:2,c:3,d:4}).map(x => x % 2 === 0) // { b: 2, d: 4 }
+   *     Sequence({a:1,b:2,c:3,d:4}).filter(x => x % 2 === 0) // { b: 2, d: 4 }
    *
    */
   filter(

dist/Immutable.dev.js

@@ -330,6 +330,17 @@ var $Sequence = Sequence;
     });
     return mappedSequence;
   },
+  mapKeys: function(mapper, thisArg) {
+    var sequence = this;
+    var mappedSequence = sequence.__makeSequence();
+    mappedSequence.length = sequence.length;
+    mappedSequence.__iterateUncached = (function(fn, reverse) {
+      return sequence.__iterate((function(v, k, c) {
+        return fn(v, mapper.call(thisArg, k, v, c), c) !== false;
+      }), reverse);
+    });
+    return mappedSequence;
+  },
   filter: function(predicate, thisArg) {
     return filterFactory(this, predicate, thisArg, true, false);
   },