Can we let `|>` be used with `...`?

as far as I can think of off the top of my head, it seems perfectly fine to do something like:

diff --git a/base/operators.jl b/base/operators.jl
index b747e76415..3b07f931b5 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -995,7 +995,7 @@ julia> [0 1; 2 3] .|> (x -> x^2) |> sum
 14
 ```
 """
-|>(x, f) = f(x)
+|>(xs...) = xs[end](xs[begin:end-1])
 
 _stable_typeof(x) = typeof(x)
 _stable_typeof(::Type{T}) where {T} = @isdefined(T) && !Core.has_free_typevars(T) ? Type{T} : DataType

which would allow things like:

julia> [1,2,5,4,3]... |> max
5

# where I wanted it...
julia> partialsortperm(sum(R, dims=2) |> vec, 1:2, rev=true)... |> minmax, partialsortperm(sum(R, dims=1) |> vec, 1:2, rev=true)... |> minmax
((128, 751), (57, 550))

julia> R[range(ans[1]...), range(ans[2]...)]

I think it’s slightly more readable than [1,2,3,4,5] |> splat(max), and I don’t think it hurts anything, right?

Splatting large collections is bad for compiler performance, so indeed it could hurt. The issue is that a collection of 100 elements being splatted into a function creates a function with 100 arguments, each with a possible distinct static type. So the type signature becomes huge.
In general, I’d use splatting sparingly: Only when you statically know the length of the splatted collection, and only when it has a handful of elements or fewer.

So, expanding the API surface for splatting could be a disservice to users, creating tempting APIs that degrade performance unexpectedly

I don’t think that would be an unexpected performance degradation, since it would be the same as max([1,2,3,4,5]...), right? it’s just letting people do what they already could with functional notation

to clarify, I’m not saying [1,2,3,4,5]... |> max is a good example; it was just the first function that came to mind