Hi,

I'd like to suggest an edit to [temp.friend] to make the standard more
clear in a use case I ran into recently. I'm writing to get feedback. The
use case is as follows; Suppose we have a template class

<template class T>
profile_integer;

This might be a arithmetic type for which we want to overload operators for
common types; and so in the definition we wish to have

<template class V>
friend profile_integer<T> operator*(const V& lhs, const profile_integer<T>&
rhs);

and we wish to define this out of line. This (and correct me here) is
impossible. When we instantiate profile_integer<T> for some concrete type T
we create a friend declaration for operator*<V> but any out of line
definition would be for operator*<T, V> and these are two different
functions. In practice this compiles but fails to link for lack of
operator*<V>.

I think adding to the example in [temp.friend] (1) Example 1 that makes it
clear that this must be an inline definition and a note in the text below
would make sense.

While all the elements to explain the above behavior exist in the standard,
to a casual reader of the standard it may not be abundantly clear and a
casual reading of the one example of a template friend of a template class
may suggest that an out of line definition is possible (it's possible if
the function signature doesn't depend on the class template type.)

If my understanding is correct and this makes sense I believe it would fall
under an editorial issue and a PR in git would be appropriate, is that
correct?

Of course I would appreciate it if the standard could support such an out
of line definition of such a function but I suspect that is non-trivial.
Please correct me here if I'm wrong.

--
Mike