Could we, perhaps, appease the functional programming folks by using |> for Hack pipes, ||> for F# pipes, and |||> for function composition? i.e.,

• x |> expr - First-order pipelining, i.e. evaluating expressions (i.e., "evaluate pipeline" or "expression pipeline"). Has a topic.
• x ||> F - Second-order pipelining, i.e. calling unary functions (i.e., "call pipeline" or "function pipeline"). Does not have a topic.
• F |||> G - Third-order pipelining, i.e. composition of unary functions (i.e., "compose pipeline"). Does not have a topic.

This makes some sense as far as first-order vs. higher-order pipeline:

// first-order
x |> F(%) |> G(%) 

// second-order
x ||> F ||> G

// third-order
// NOTE: this is backwards from f . g === g(f(x)), but perhaps we 
//       could introduce a "back pipe" `<|||` as a true point/compose operator
x ||> (F |||> G)
x |> (F |||> G)(%)

And if we wanted true point/compose, we could pair it with "back pipes" like in F#:

G(%) <| F(%) <| x // trickier to parse though
G <|| F <|| x
(G <||| F) <|| x

The back-pipe variant has similarities to decorator application as well:

class C {
  @F
  @G
  method() {}
}
 
F <||
G <||
function () {}

For example, suppose we had my functional operators and PFA proposals:

a * b + c
a {*} b {+} c 
plus(times(a, b), c)

// first-order
a |> % * b |> % + c
a |> % {*} b |> % {+} c
a |> times(a, b) |> plus(%, c)
 
// second-order
a ||> {*} b ||> {+} c
a ||> times~(?, b) ||> plus~(?, c)
 
// third-order
a ||> ({*} b |||> {+} c)
a ||> (times~(?, b) |||> plus~(?, c))

Yeah, agreed, but I think that requiring separation between the topic and binary */** might not be a big cost.

I suspect maybe >90% of uses of pipe will be with function calls or object/array/tuple/record literals f() |> g(#[*], 0), and it may be worth optimizing readability for those cases, rather than for f() |> * ** 2. And even f() |> * ** 2 isn’t that unreadable, I think.

It’s worth at least considering, since it probably is basically the only single-character token left.

~ is nice and we haven’t discussed it properly either. f() |> g(#[~], 0) |> ~(~), hmm…

PFA syntax would use ~. But f() |> (~)~(0, ?) would be quite rare!

At least it will throw if it’s the only expected use of topic in the pipe body.

f() |> ~(2) would be a SyntaxError: “Pipe body contains no topic.”

(f() |> #[~(2), ~ + 1] would not be a SyntaxError, but is that situation going to be common? Hmm.)