Pipeline + Partial Application + await/yield

[azz]

Context: https://github.com/tc39/proposal-pipeline-operator/issues/53

Does it make sense to introduce a way to integrate the syntax of this proposal and the pipeline proposal in the case of async functions?

If it was legal to place await within a partially applied function when part of a pipeline, then:

const foo = await (1
  |> addOne(await?)
  |> double(await?)
);

would be loosely equivalent to:

const foo = await (1
  |> async x => await addOne(x)
  |> async x => await double(x)
);

which in turn is loosely:

const foo = (
  await double(
    await addOne(
      1
    )
  )
);

---

Syntax alternative:

const foo = 1
  |> await addOne(?)
  |> await double(?)

[gilbert]

I think with the current proposal semantics, it would be translated this way:

double(await ?)
//=>
double(x => await x)

...because the ? operator only applies to the immediately surrounding invocation (hence the motivation for #13).

[rbuckton]

If partial application results in eager evaluation, I would need to add a special form for ? to allow await ? to work, but in that case the semantics are more like:

const foo = await (1
  |> (async x => addOne(await x))
  |> (async y => double(await y))
);

Another approach might be to have some syntax for an async pipeline, similar to for await, e.g.:

const foo = 1
  await |> addOne(?)
  await |> double(?);

[phaux]

You can easily achieve the same thing without a special syntax:

const foo = await p
  .then(addOne(?))
  .then(double(?))

[azz]

Wouldn't addOne(?) be the same as x => addOne(x) ?

[dead-claudia]

Yes, but the point is that with promises, it's moderately a moot point because we already have then.

[rbuckton]

Given that the pipeline proposal has moved forward with Hack-style, and the new syntax and semantics from #49, this is no longer an issue for partial application.

Since partial application is eager, f~(await p, ?) would perform the following steps:

1. Evaluate f (we'll call that _f for the purpose of this algorithm)
2. Evaluate p (as _p)
3. Evaluate await _p (as _await_p)
4. Produce a partially applied function for _f~(_await_p, ?)

The same would apply to yield.

I've added these along with desugaring examples to EXAMPLE.md in the repository root.