Holy wow that was fast! You’re a wizard! Admittedly I began looking into writing a macro to do this, but you beat me to the punch by a wide country mile

This is really cool! Although, two complaints:

- I’ve begun to use the
`++`

operator for the *parallel sum*, as seen here.
- This macro doesn’t yet work for broadcasting a function across a collection, e.g.
`[1,2,3]++sqrt.()`

.

I know I know, eventually we’d settle on dash `--`

, I’m pulling your leg.

This is really great. I like the “peace pipe” reference too.

Masterful. I’m going to play with this for a while, and maybe some other folks can play with it too and see what else it’s good for (and what it’s not).

Similar to dash `--`

, `/>`

and `\>`

are not valid operators, which means we would need them to be added into the language first; it also means we could claim them without breaking backwards compatibility in any packages or programs, if we can convince the Julia devs to incorporate them.

There was a brief moment when I was considering emdash `---`

for piping the object into the last argument position, such as `arr---map(sqrt)`

. If it has otherwise the same properties as we have chosen for dash `--`

(higher precedence than function call, and right-associativity), then the following is `true`

:

```
f(a, b, c, d) ==
d---f(a, b, c) ==
c---d---f(a, b) ==
b---c---d---f(a) ==
a---b---c---d---f()
```

This operator would be nice for `map`

, `reduce`

, `filter`

, etc., and especially well-suited for `mapreduce`

, e.g.:

```
[1, 2, 3]---filter(iseven)---map(sqrt) == # using emdash
[1, 2, 3]--iseven--filter()--sqrt--map() # using dash
[1, 2, 3]---mapreduce(x->x^2, +) == # using emdash
[1, 2, 3]--(+)--(x->x^2)--mapreduce() # using dash
```

And if dash `--`

and emdash `---`

have the same precedence, then they should chain as expected, e.g.:

```
[1, 2, 3]---mapreduce(x->x^2, +)--sqrt() ==
[1, 2, 3]--(x->x^2)--map()--(+)--reduce()--sqrt() ==
sqrt(mapreduce(x->x^2, +, [1, 2, 3]))
```

However, I’ve begun thinking that dash `--`

is sufficiently expressive to cover the vast majority of use cases, that the ease of typing it beats the other options we’ve considered (except perhaps `..`

), and that adding more and other operators to serve these purposes would bring more confusion and mental loading than it’s worth.

But I’m open to the idea that I’m wrong. Maybe you can convince me?