better inlining of splatting with tuples of known length

[stevengj]

Since ntuple has a variant that works with Val{N} (which I learned recently from @JeffBezanson), I was hoping that the compiler could do a good job with:

foo{N}(f, args::Vararg{Any,N}) = f(ntuple(i -> args[i]+1, Val{N})...)

but foo(+, 1,2) seems to be quite slow — 200x slower (according to @btime) than bar(+, 1,2) for bar(f,x,y) = f(x+1,y+1), and @code_llvm foo(+, 1,2) is nasty looking.

I realize that I could use generated functions for this, but I was hoping to avoid that.

[timholy]

The standard workaround is to add @inline and only benchmark callers:

julia> @inline foo{N}(f, args::Vararg{Any,N}) = f(ntuple(i -> args[i]+1, Val{N})...)
foo (generic function with 1 method)

julia> foocaller() = foo(+, 1, 2)
foocaller (generic function with 1 method)

julia> @benchmark foocaller()
BenchmarkTools.Trial: 
  samples:          10000
  evals/sample:     1000
  time tolerance:   5.00%
  memory tolerance: 1.00%
  memory estimate:  0.00 bytes
  allocs estimate:  0
  minimum time:     4.00 ns (0.00% GC)
  median time:      4.00 ns (0.00% GC)
  mean time:        4.01 ns (0.00% GC)
  maximum time:     24.00 ns (0.00% GC)

Obviously it's not exactly wonderful to require inlining to get tolerable performance from splatted functions, but that's where we are now.

I'm not sure there is anything here that's not in other open issues about splatting, so maybe close?