Weird behavior in reduce function

I am experiencing different behavior with the reduce function. Those two functions have different behaviors:

const fromListToMap = R.reduce((acc, attr) => {
  acc[attr.name] = attr.value
  return acc
}, {})

const fromListToMapWithoutCurrying = list => R.reduce((acc, attr) => {
  acc[attr.name] = attr.value
  return acc
}, {})(list)

Input:

[
  [
    { "name": "toto", "value": "toto1"}
  ],
  [
    { "name": "tata", "value": "tata1"}
  ],
]

Calling

 R.map(fromListToMap)(input)

returns

[
  {
    "toto": "toto1",
    "tata": "tata1"
  },
  {
    "toto": "toto1",
    "tata": "tata1"
  }

instead of

[
  {
    "toto": "toto1",
  },
  {
    "tata": "tata1"
  }

Is this a bug or an is it the expected behavior?

[buzzdecafe]

I appreciate what you are trying to accomplish, and I support your desire to see these functions behave in a truly immutable way. However, I think bolting immutability onto a language that does not provide support for it – in fact, the base language is actively hostile to it – is a very difficult challenge.

Ultimately, there is no way to ensure that the reducing function is pure. And the stringify/parse solution for cloning is too naive. Suppose I am folding onto a FL-compliant Functor with map defined on the prototype? This is a common use case for Ramda users. That would fail immediately, since the clone would ignore prototype properties; and JSON does not serialize functions. Perf would already be bad using stringify/parse; now you have to accommodate cloning (or somehow reattaching) prototype properties as well?

So should you try to prove this concept, expect some skepticism. A comprehensive solution may not be so easy to reach.

[kedashoe]

the second argument is the same for each function call. Is it correct?

I would not say that it is the same, the second argument is the initial value, and it is re-assigned at every step of the reduction: https://github.com/ramda/ramda/blob/v0.24.1/src/internal/_reduce.js#L11.

This argument is passed to our reducing function. In your case, you are mutating that argument:

acc[attr.name] = attr.value

, which is why you are seeing the behaviour that you are. If you were to rewrite it without using mutation, eg with R.assoc, which does not mutate its input:

const fromListToMap = R.reduce((acc, attr) => {
  return R.assoc(attr.name, attr.value, acc);
}, {})

const fromListToMapWithoutCurrying = list => R.reduce((acc, attr) => {
  return R.assoc(attr.name, attr.value, acc);
}, {})(list)

then I think you would get what you initially expected: https://goo.gl/KvxVtP