Pipeline Placeholders

[gilbert]

I'd like to explore an alternative to the partial application proposal that would only be used in conjunction with the pipeline operator.

There has been discussion around using ? as a placeholder for functions with multiple arguments. Consider the readme example:

let person = { score: 25 };

let newScore = person.score
  |> double
  |> (_ => add(7, _))
  |> (_ => boundScore(0, 100, _));

newScore //=> 57

If the ? were to be built into the pipeline operator, we could rewrite the example to the following:

let newScore = person.score
  |> double
  |> add(7, ?)
  |> boundScore(0, 100, ?);

and since this placeholder is scoped to the pipeline operator, it has the potential to be more expressive:

let ex1 = person |> double(?.score);
let ex2 = person.score |> add(?, ?);

and potentially allow member expressions?

let x = 10 |> f |> ?.foo |> g;

On the other hand, any sort of ? placeholder might have people let write strange things like
x |> f(? ? ? : 10). Is this problematic?

[jEnbuska]

It could be a bit confusing

function plus(number1, number2=1){
  return number1+number2
}
function curringMultiply(target){
   return (multiplier) => target*multiplier;
}
const a = 10;
2 |> addition(?); // 3
2 |> addition(?, a) // Error?
2 |> it => addition(it, a) //12
2 |> curryingMultiply(a) // what happens here...
2 |> curryingMultiply(?) // ... or here
2 |> (it) => curryingMultiply(a)(it) // 20

[littledan]

@gilbert This is an interesting idea. I'm not sure if we're ready to forclose on partial application completely, even if it got somewhat chilly reception the first time around (lots of proposals do); I'd like to form this as a strict subset of what could grow into a partial application proposal if it's picked up again. So far, though, this sketch seems without any particular contractions, except for the ?. part, which is an unfortunate overlap with the optional chaining operator.

@jEnbuska I don't really see what's ambiguous about the semantics in those cases. Could you explain what the confusion is? I could write out the semantics I'm imagining

cc @rbuckton @bterlson

[jEnbuska]

@littledan I just wasn't syntax, but I think I get it now.

[Alexsey]

@gilbert What should we get from limiting usage of partial application to pipleline operator? All examples you provide could exists without this limitation

[littledan]

@Alexsey A worry from TC39 is that partial application is too confusing, syntactically and otherwise, in general. Maybe the restriction to just this pace could make it easier to understand.

[davegregg]

@Alexsey It's a bit like a shorthand for arguments[0], or possibly a "last value" accessor. Here are some imaginative examples:

A: const print = function { console.log(?) }; print('Hello, world!');

B: { console.log(?) }('Hello, world!')

C: for (myArray) { console.log(?) }

D: myArray.map(val => ? + value)

But I have problems with these which make me want to say that this syntax should be scoped to the pipeline:

1. Ambiguity with potential other uses, e.g. ternaries, optional chaining, null coalescing -- particularly when compounded with optional whitespace and leading zeros in decimals.

2. These uses don't look that useful and the "last value" accessor concept could be a real performance issue.

[Alexsey]

@davegregg The examples you provide are out of the scope of partial application proposal as well as out of scope of discussion of limiting partial application usage to pipeline operator. They are like about usage of partial application in function bodies. There is already a discussion on that in the partial application repo

[trustedtomato]

@gilbert I've made a proposal which would enable your suggestions. According to that proposal, your examples could be rewritten as:

let newScore = person.score
  |> double
  |> #add(7, ?)
  |> #boundScore(0, 100, ?);

let ex1 = person |> #double(?.score);
// I'm not sure what you meant here, but tried to guess
let ex2 = #(person.score |> #add(??, ?));
// But without pipeline, it would be more pretty
let ex2v2 = #add(person.score, ?)); // Note that the evaluation if deferred

let x = 10 |> f |> #?.foo |> g;

[gilbert]

What should we get from limiting usage of partial application to pipleline operator? All examples you provide could exists without this limitation

We would get a removal of ambiguity without needing to introduce another syntactic marker.

[Alexsey]

@gilbert Ok, that sounds like an argument. So may be discussion should be about allowance of not using syntactic marker for partial application in the the pipelines? I think it could be a good addition to the discussion you have mentioned in your post

[rauschma]

I think this is a great idea! IMO, this is the main use case for partial application. Other than that, arrow functions work perfectly.

This is how Facebook’s Hack does it ($$ instead of ?):

function piped_example(array<int> $arr): int {
  return $arr
    |> array_map($x ==> $x * $x, $$)
    |> array_filter($$, $x ==> $x % 2 == 0)
    |> count($$);
}

One nice trait of this extension is that it doesn’t affect code written for the proposal as it currently exists. It is completely optional.

[littledan]

@rbuckton @bterlson What do you think of this direction for the pipeline operator? I don't want to step on your toes in your work on the partial application proposal.

[zenparsing]

I first thought this idea should be limited to just argument placeholder positions, but it's interesting to think of ? in this context as variable binding scoped to the expression on the right hand side of |>.

One of the issues I see with the pipeline operator is that it doesn't integrate well with normal method chaining. If I'm doing some operations on arrays, for instance, I might want to chain using some built-in array methods and some functions coming from another library. Currently I'd have to use arrow functions:

I'm not very good at these examples...

anArray
 |> pickEveryOther
 |> (_ => _.filter(...))
 |> shuffle
 |> (_ => _.map(...));

This feels awkward and unfortunate.

With a placeholder binding, perhaps I could do something like:

anArray
  |> pickEveryOther
  |> ?.filter(...)
  |> shuffle
  |> ?.map(...);

Given ternary expressions (and the other potential uses for ?), I don't think ? is going to work though. Are there any other tokens that might work better?

[littledan]

There are a lot of open questions about how pipeline placeholders should work. In addition to the receiver position, a placeholder could also go in nested function calls, in an object literal and as an argument to a binary operator. The partial application proposal decided to scope all of these out, and this was a point of criticism for that proposal. We'll have to think carefully about many cases as part of deciding which token makes sense.