Pipeline with spread operator?

[hakatashi]

As mentioned in #23 (comment), this proposal will be more powerful when it supports spread operator .... In short, make something like the following

...[100, 200] |> Math.max

equivalent to the following.

Math.max(...[100, 200]) //=> 200

This change will fantastically make the pipeline able to pass more than one argument to the callee.

I suspect whether this would be legal when it chained more than one times. Obviously the following is valid,

...(...[10, 20] |> ((a, b) => [a + 5, b + 5])) |> console.log

but it would be nice to have something like the following

...[10, 20] |> ...((a, b) => [a + 5, b + 5]) |> console.log

and it's equivalent to the following.

console.log(...(((a, b) => [a + 5, b + 5])(...[10, 20]))) // prints '15 25'

Note that, since the spread operator is not a general unary operator and something like foo = ...bar; is not permitted syntactically, I think this kind of extension will result in a syntax extension of spread operator itself.

[nmn]

I don't see a big reason for this as arrow function pretty much solve the issue already:

// ...[100, 200] |> Math.max
[100, 200]
  |> _ => Math.max(..._)

// ...(...[10, 20] |> ((a, b) => [a + 5, b + 5])) |> console.log
[10, 20]
  |> ([a, b]) => [a + 5, b + 5]
  |> _ => console.log(..._)
// console.log will also work correctly now. (It's not bound and would be missing a this in your example)

Adding the extra spread syntax is confusing to read, and the alternative is easier to read.
Using arrow functions also doesn't have a downside as VMs can optimize them as much as the spreads. In fact the newly added Babel plugin already optimizes simple arrow functions to remove the function call altogether.

ALSO:
If using an arrow function with a spread is too much for you, you could also easily make a helper higher order function.

const apply = (fn, ctx = null) => args => fn.apply(ctx, args);

// ...[100, 200] |> Math.max
[100, 200]
  |> apply(Math.max)

// ...(...[10, 20] |> ((a, b) => [a + 5, b + 5])) |> console.log
[10, 20]
  |> apply((a, b) => [a + 5, b + 5])
  |> apply(console.log, console)

Here the apply function will also help with context. I'm all for adding functions like this to JS eventually, but I don't think we should add syntax unless it actually helps.

[mAAdhaTTah]

I'm 👎 on this. This looks like too much magic and confusion for what can already be done with arrow functions inline, or using a helper function for.

[littledan]

OK, seems like a lot of opposition to this proposal, so closing this issue.