only for those tuple of concrete argument types

[raman-maker]

https://github.com/JuliaLang/julia/blame/a23ce4bcbbb06be413169424cbffee0718b8a431/doc/src/manual/types.md#L253

Please write it as
""because it is recompiled only for those tuple of concrete
argument types with which it is invoked.""

[barucden]

An important point to note is that there is no loss in performance 
if the programmer relies on a function whose arguments are abstract types, 
because it is recompiled
- for each tuple of concrete argument types with which it is invoked.
+ only for those tuples of concrete argument types with which it is invoked.

Is this what you propose?

As a non-native speaker, I might be missing some nuances. Would you mind explaining in what sense is the proposed description better than the current one?

[mbauman]

This is definitely saying what it intends in my view. The point is that even if a method is defined with abstract argument types, it won't be type unstable (or perform worse than writing it with non-abstract types) because it will compile a new specialization for all the concrete argument types it is called with. There's an unwritten asterisk to that statement, but that's #51423.

Could you expand on what you think the current text is missing, @raman-maker?

[Seelengrab]

To me, the version with only reads as an exclusion of any other tuples. In particular, it excludes the signature itself!

So for a function like this:

f(x::Integer) = 2*x

And having some other code like (with no other callers of f):

function main()
    println(f(1))
    println(f(0x1))
end

Julia will end up compiling f(::Int) and f(::UInt8), but NOT a generic fallback to f(::Integer) or even f(::Int16). I.e., even though there could be more tuples to compile for, ONLY the ones actually invoked are compiled.

It's a subtle difference, but the "only" places the emphasis on exclusively those tuples that are needed.

[raman-maker]

An important point to note is that there is no loss in performance
if the programmer relies on a function whose arguments are abstract types,
because it is recompiled
- for each tuple of concrete argument types with which it is invoked.
+ for only invoked tuples of concrete argument types.

• It's a subtle difference, but the "only" places the emphasis on exclusively those tuples that are needed.

• Suppose if declaration of function f(x::Integer) = 2*x compiles every concrete type combinations then we should loose performance.

First of all i do not know much about internal of Julia. I am confused about those words. Please do some changes that you think are best.

[StefanKarpinski]

I'm not really following the confusion here and the original wording seems clearer to me. Perhaps you are thinking about compilation performance, whereas the sentence is about runtime performance? You seem to be trying to imply a limit on how much compilation is done, whereas the sentence is about how fast the compiled code that is run will ultimately be.

[raman-maker]

Ok, Thank You Sir. Please do what ever changes that would reduce confusion.