It’s been a long time, and yet I’m realizing now that nobody seems to have proposed .. as the topic reference.

x = grunt.config('uglify.all.files') |> Object.keys(..)[0];
x = pkgs[0] |> npa(..).escapedName |> await npmFetch.json(.., opts);
x = cb(predicate) |> _.negate(..) |> _.filter(obj, .., context);
Object.keys(envars)
  .map(envar => `${envar}=${envars[envar]}`)
  .join(' ')
  |> `$ ${..}`
  |> chalk.dim(.., 'node', args.join(' '))
  |> console.log(..);
context
  |> (.. && (..).nodeType ? (..).ownerDocument || .. : document)
  |> jQuery.parseHTML(match[1], .., true)
  |> jQuery.merge(..);

.. as the topic doesn’t seem bad. It only really clashes with property accesses—which are already postfix, so you would rarely use pipe on them anyway. And spread syntax, I guess, but doing that on the topic would probably be even rarer.

.. is even more visually lightweight than ^^, and it’s easier to type than ^^ and %%.
Plus, .. usually gets its own typographic ligatures in fancy code fonts, for those who are into those.

I don’t think having an iterable topic would be rare, but I do think that spreading an iterable topic into a function call or array/object literal within a pipe would be pretty rare.

// How often would you need to spread a topic
// into a variadic function?
x |> fnThatReturnsIter(..) |> variadicFn(...(..)) |> g(.., 0)
// Maybe "appending" a value into an array copy is more common:
x |> fnThatReturnsIter(..) |> [ ...(..), 0 ]

Though, even when it does happen, f(...(..)) or [ ...(..) ] wouldn't be the end of the world either. I think that they might be worth the tradeoff versus the disadvantages of %% or ^^. And my intuition is that .. would be significantly easier to parse than %% or ^^, too.

Yeah, I’ll acquiesce that flattening into Math.max and min does happen. Though I’d be a bit surprised if such calls exceeded 0.1%, let alone 1%, of all JS function calls that would benefit from piping.
And just a space separating ... and .. should work, without parentheses, right? x |> [... ..] rather than x |> [...(..)].

arr |> Math.min(0, ... ..) |> console.log(`Max is {..}`);
arr |> Math.min(0, ...^^) |> console.log(`Max is {^^}`);
arr |> Math.min(0, ...%%) |> console.log(`Max is {%%}`);
arr |> Math.min(0, ...#_) |> console.log(`Max is {#_}`);

I’m actually kind of excited about .. as another candidate topic token. It’s so “lightweight” compared to the other choices left.

the main advantage for the reader of f# is that it probably wouldn't be arrow functions, and would instead be curried functions - so looks almost like method calls. If every f# pipe was an arrow that sounds verbose

getData() |> _ => Object.entries(_) |> _ => handleEntries(_) |> _ => Object.fromEntries(_);

vs

getData() |> Object.entries(^^) |> handleEntries(^^) |> Object.fromEntries(^^);