Object-preserving map() function

[ThiefMaster]

Would it be possible to add a map()-like function (since changing the current one would break things) which works exactly like map() but returns an object instead of an array if an object was passed?

Example:

_.map2({abc: 123, xyz: '6', foo: '9'}, function(num, key) {
    return parseInt(num, 10);
});
=> {abc: 123, xyz: 6, foo: 9}

It might also make sense to have it return [key, value] tuples but just modifying the values might be sufficient for many cases.

[amasad]

That would be very handy.
Having both options of returning either a key/value tuple or a single value would be great.

[greylurk]

That seems like the same functionality could be obtained by slightly re-writing your iterator to an each() function:

_.each({abc: 123, xyz: '6', foo: '9'}, function( key, value, obj ) {
  obj[key] = parseInt(val,10);
});

=> {abc: 123, xyz: 6, foo: 9}

Is this just a syntactic sugar?

[amasad]

@greylurk Two reasons why your technique can't accomplish what is needed:

• The native forEach and the _.each methods always returns undefined and not the list.
• By definition the map function would return a new list and keeps the original list unmodified (which is essential).

[ThiefMaster]

I think he meant map to return a new object.

[jashkenas]

What you proposed isn't a true object map, which would be able to specify the keys as well as the values of the returned object. There are several interesting versions of object mapping, none of which are mainstream enough to deserve to make it into Underscore proper -- all of which are quite useful as _.mixin functions, for your own purposes, or for an Underscore extension.

[mrkurt]

Would a mapValues be more generically useful? I find myself wanting to do that pretty frequently after a groupBy.

[adrianheine]

I recently used an implementation like the following:

_.mixin({
    mapValues: function (input, mapper) {
        return _.reduce(input, function (obj, v, k) {
            obj[k] = mapper(v, k, input);
        }, {});
    }
});

[yuchi]

Completely OT: I propose a hipster-underscore extension which implements all the mixins not enough mainstream to make it into the official repo.

The motto is: I used an associative map function way before it made into underscore

[mahemoff]

yuchi - an "overscore" library, good move that.

[yuchi]

+1 for Overscore.js: Underscore.js for hipsters

[jashkenas]

+1 for Overscore.js

[eeroan]

You forgot to return the obj. With this modification it works:

_.mixin({
    mapValues: function (input, mapper) {
        return _.reduce(input, function (obj, v, k) {
            obj[k] = mapper(v, k, input);
            return obj;
        }, {});
    }
});

[eethann]

Apparently hipsters don't care about context.

This update allows _.mapValues(list, iterator, this) to work, etc.

_.mixin({
  mapValues: function (input, mapper, context) {
    return _.reduce(input, function (obj, v, k) {
      obj[k] = mapper.call(context, v, k, input);
      return obj;
    }, {}, context);
  }
});

Created a gist to track any further revisions: https://gist.github.com/3430971

[kennknowles]

I was about to submit a pull request for this and I am surprised to see that it has been discarded as "not mainstream". There are two major reasons for my surprise:

(1) It is mainstream in the sense of being in basically all standard libraries for languages advanced enough to think about such things:

• Scala
• Clojure
• OCaml
• Haskell
• F#

Racket, Ruby, and Python share Underscore's behavior of (more or less) coercing dictionaries to a list first. Languages such as Java, Go, and C# are too first-order (in spirit, though at this point they could advance) to have equivalent libraries at all. Common Lisp doesn't even return a value... Basically the further back in time you go, the less like mapValues you get.

Underscore is a step ahead of Java but a step behind modern FP. Clojure is evidence that it does not require types, though they undoubtedly played a part in people eventually figuring this out. And this is figured out, which is my second reason.

(2) This is the fundamental map over dictionaries in the sense of them being a functor - the concept that unifies all "container" data structures (used in random incorrect ways by C++, Ruby, and Prolog, so just don't go there). Those languages advanced enough to express this have done so: Haskell, Scala, Clojure. Someone even experimented with the idea in our own Javascript.

As you say, there are several interesting maps on dictionaries. A good start would be mapKeys and mapValues. I know that Javascript objects are not exactly dictionaries, and that the current map behavior comes from the (appropriate) behavior on arrays, but just use a different name and save everyone from reimplementing this over and over. It really seems like it is in the spirit of Underscore's adoption of pithy and standard functions.

Please reconsider, @jashkenas.

+1

-- Kenn