When an expression that references a template parameter is used in the
function parameter list or the return type in the declaration of a
function template, the expression that references the template
parameter is part of the signature of the function template.

This is
necessary to permit a declaration of a function template in one
translation unit to be linked with another declaration of the function
template in another translation unit and, conversely, to ensure that
function templates that are intended to be distinct are not linked
with one another.

Two expressions involving template parameters are considered
equivalent
if two function definitions containing the expressions would satisfy
the one-definition rule, except that the tokens used
to name the template parameters may differ as long as a token used to
name a template parameter in one expression is replaced by another token
that names the same template parameter in the other expression.

Two expressions involving template parameters that are not equivalent are
functionally equivalent
if, for any given set of template arguments, the evaluation of the
expression results in the same value.

Two function templates are
equivalent
if they
are declared in the same scope,
have the same name,
have equivalent template-heads,
and
have return types, parameter lists,
and trailing requires-clauses (if any)
that are equivalent using the rules described above to compare
expressions involving
template parameters.

Two function templates are
functionally equivalent
if they
are declared in the same scope,
have the same name,
accept and are satisfied by the same set of template argument lists,
and
have return types and parameter lists that
are functionally equivalent using the rules described above to
compare expressions involving
template parameters.

If the validity or meaning of the program depends on
whether two constructs are equivalent, and they are
functionally equivalent but not equivalent, the program is ill-formed,
no diagnostic required.

This rule guarantees that equivalent declarations will be linked with
one another, while not requiring implementations to use heroic efforts
to guarantee that functionally equivalent declarations will be treated
as distinct.

For example, the last two declarations are functionally
equivalent and would cause a program to be ill-formed: