Question: R.curryN with R.__ placeholder

[objectisundefined]

// R.curry document example
var f = (a, b, c) => [a, b, c]
var g = R.curry(f)

// _ is R.__
// what should g(1, _)(_, 2, _, 'a') returns?
// result is [ 1, _, 2 ] now

Ramda doesn't limit arguments length, but it also reduces left arguments length when
combinedIdx is larger than fn's length

// src/internal/_curryN.js

function _curryN(length, received, fn) {
  return function () {
    var combined = [];
    var argsIdx = 0;
    var left = length;
    var combinedIdx = 0;
    while (combinedIdx < received.length || argsIdx < arguments.length) {
      var result;
      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
        result = received[combinedIdx];
      } else {
        result = arguments[argsIdx];
        argsIdx += 1;
      }
      combined[combinedIdx] = result;
      if (!_isPlaceholder(result)) {
        left -= 1;
      }
      combinedIdx += 1;
    }
    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));
  };
}

[CrossEye]

This does seem far less than ideal. Do you have a recommendation?

Note that g(1)(_, 2, _, 'a') is a simpler demonstration.

[objectisundefined]

Should we call fn when all placeholders were filled? Or only check placeholders in the first N args?

[CrossEye]

In keeping with other Ramda functions, I would like to pass along extra arguments if they're supplied. So g(1)(_, 3)(2, 'a') should yield f(1, 2, 3, 'a'), even though f only has arity 3.

But it's not clear to me what the behavior of g(1)(_, 2, _, 'a') should be.