Why curry fn will return value when developer doesn't pass enough params？

[manyuemeiquqi]

When i view curry function, i find curry will return placeHolder when i pass params that not seems correctly?
e.g.

var _ = R.__;
const h = R.curry((a, b, c,e,f) =>({
  a,b,c,e,f
}));


h(_,2,_,_,_,_,_)(8)(_,2,3,4)

It will happen the following

I'm not sure it is expected.
If not
I think curry cound impore it with modify internal implementation

[CrossEye]

I do think you've found a bug. I don't know why the console ends up with the <Circular> notation. But that's not the important point. As you note, we can see by logging the results, that the c parameter ends up with the placeholder argument as its value. That's just wrong.

Note that the string of placeholders at the end of the first call have no effect. Here is a simplified example showing the issue:

const _ = R.__;
const h = R.curry((a, b, c, d, e) =>({
  a, b, c, d, e
}));

const r = h(1, 2)(_, 4, 5, 3)
const s = h(1, 2)(_, 4, 5)(3)

console.log(r) //=> {a:1, b: 2, c: R.__, d: 4, e: 5}  // Oops!
console.log(s) //=> {a:1, b: 2, c: 3, d: 4, e: 5}     // Works ok

Have you done any digging into the source code to determine why this happens? I assume it's because the call with (_, 4, 5, 3) has enough parameters to let curry know that it's complete, but then one of those parameters is still a placeholder.

Any interest in trying to write a PR to solve this?

[manyuemeiquqi]

I attempt fix it, PR

[CrossEye]

Note the question I raised on the PR: #3410 (comment)

I think there is a fundamental question here we need to answer before we settle on a solution.

What should we do with extra parameters? Our answer has been to pass them along, but we hadn't considered this case of passing too many with the placeholder displacing them. Now we have to make a more fundamental decision. Which of these (at least somewhat reasonable) results should we expect?"

const g = R.curry(function (a, b, c) {return [...arguments]})
g(_, 2, 3, 4)(_, 5, 6)(_, 7, 8, 9)(1, 10)
  //?=> [1, 2, 3]
  //?=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  //?=> [1, 2, 3, 10]

Or are there other possibilities? While there is a lot to be said for the first answer, my guess is that would be a breaking change. The second one seems the most likely extension of how we do things in Ramda, but the third is arguably more correct.

I think we need to address this before merging any code.