Reduce for Objects?

I find myself trying to turn Objects into other types pretty frequently and find myself doing something like:

Object.keys(myObj).reduce((acc, key) =>  doSomething(key, myObj[key]), someAccumulator)

the other part of the time I want to return early from the iteration and that ends up being the only time I really have to reach for a for loop.

What I’m hoping for is a function like:

reduceObject :: (b -> a -> String -> b) -> Object a -> b I know this isn’t strictly the same as ramda’s reduce so I can see adding a separate function to deal with this case.

[CrossEye]

#257, #364, #546, #625, #656, #920, #1067

The problem is this sort of concern:

var diff = function(x, y) {return y - x;}, 
    obj1 = {a: 1, b: 2, c: 3}, 
    obj2 = {b: 2, a: 1, c: 3};
_.reduce(obj1, diff); //=> 2
_.reduce(obj2, diff); //=> 4

obj1 and obj2 differ only in the order of key definition.

If we did something like that in Ramda, we’d violate a law that I’d like to maintain:

if R.equals(x, y), then R.equals(f(x), f(y)) for any f.

#1067 was a long discussion, and involved one proposal that would allow us to do this but was pretty controversial: apply our own sort to keys before any function where it might matter.

[paldepind]

@CrossEye

We’ve been over this before 😄 But as was discussed in #1067 we’re already violating the law:

R.equals({a: 1, b:2}, {b: 2, a: 1}); //=> true
R.equals(R.keys({a: 1, b:2}), R.keys({b: 2, a: 1})); //=> false

So, should we remove R.keys and the other functions you mention here? Why do these function get to stay?

The way I see it our users keeps asking us to add this function and we keep trying to convince them it’s bad for them.

To me the use case seems covered by R.values and R.toPairs

R.reduceRight(([val, acc]) => ..., R.toPairs(object));

This also has advantage that R.toPairs can be used with R.reduceWhile which might be useful for the early return you mention @jethrolarson.

But this also leads me to the question: If we’re already giving people something that is just as dangerous but just slightly less convenient why not give them the real thing?

I’m indifferent. I think a fine solution would be to add an example of reducing an object to the documentation for R.toPairs.