Hi all, jschoi invited me to this channel. I expressed the position during the meeting today that I think it would be worthwhile to continue exploring the space of API functions for method chaining. Although the Function.pipe proposal didn't reach Stage 1, I think it would be helpful to consider that direction in the context of the Pipeline proposal.

The Pipeline champions considered "hack style" and "F# style" options for the pipeline proposal. I would like to see how the use cases would pan out with a third "API style" option. In other words, take the examples that motivate the pipeline syntax operator and show how they would work with Function.pipe, Function.pipeAsync, etc.

Anyways, regarding your new issue, it might be worth at least exploring the possibility of replacing operators with API. But I suspect it will not get far. For example, consider the explainer’s first example, from React:

console.log(
  chalk.dim(
    `$ ${Object.keys(envars)
      .map(envar =>
        `${envar}=${envars[envar]}`)
      .join(' ')
    }`,
    'node',
    args.join(' ')));

This is not an example where the pipe function would shine compared to the pipe operator (especially given the encouraging-throwaway-closures concern from the engines):

pipe(
  Object.keys(envars)
    .map(envar => `${envar}=${envars[envar]}`)
    .join(' '),
  v => `$ ${v}`,
  v => chalk.dim(v, 'node', args.join(' ')),
  console.log,
);

The explainer’s “real-world code” section has many examples like this.