CS>T const function();
CS>const T function();

CS>T const function();
CS>const T function();
CS>

struct I {};

typedef I& RInt;

const RInt f1();
RInt const f2();

int main()
{
   I& ri = f1();
   return 0;
}

Comeau:
"ComeauTest.c", line 9: warning: type qualifiers are meaningless in this declaration
const RInt f1();
^

"ComeauTest.c", line 10: warning: type qualifiers are meaningless in this
declaration
RInt const f2();
^

    ++C(f());

CS>>T const function();
CS>>const T function();
I>

const char* function();

class collection
{
  ...
  const value operator[](int i) const { return get_item_at(i); } 
}

collection coll;
coll[2].mutating_method();

collection coll;
coll[2].const_method();

CS>const char* function();

CS>class collection
CS>{
CS>  ...
CS>  const value operator[](int i) const { return get_item_at(i); } 
CS>}

CS>collection coll;
CS>coll[2].mutating_method();

void f(value v)
{
    v.mutating_method();
}

collection coll;
f(coll[2]);

CS>>const char* function();
I>

CS>>collection coll;
CS>>coll[2].mutating_method(); 
I>

I>void f(value v)
I>{
I>    v.mutating_method();
I>}

I>collection coll;
I>f(coll[2]);
I>

void f(value v)

void f(value& v)

collection coll;
f(coll[2]);

void f(const value& v)

CS>>>T const function();
CS>>>const T function();
I>>

3.10/5
The result of calling a function that does not return a reference is an rvalue.

3.10/9
Class rvalues can have cv-qualified types; non-class rvalues always have cv-unqualified types.

int f1();
int const f2();
 
template <class T>
    void g(T &);
int g(double);

int main()
{
    sizeof g(f1());
    sizeof g(f2()); // VC++ & GNU C++: T is deduced to be 'const int'
}

int f1() { return 0; }
int const f2() { return 0; }

int main()
{
    int (&r1)() = f1;
    int (&r2)() = f2; // ill-formed
}

CS>>>const char* function();

CS>void f(value v)

1.3.1 argument
an expression in the comma-separated list bounded by the parentheses in a function call expression, a sequence of preprocessing tokens in the comma-separated list bounded by the parentheses in a function-like macro invocation, the operand of throw, or an expression, type-id or template-name in the comma-separated list bounded by the angle brackets in a template instantiation. Also known as an actual argument or actual parameter.

3.10 Lvalues and rvalues
1 Every expression is either an lvalue or an rvalue.

Избегайте реализации абстракции массива посредством массивов в стиле C, арифметики указателей и примитивов управления памятью. Использование vector и string не только сделает проще вашу жизнь, но и позволит написать более безопасную и масштабируемую программу.

14.8.2.1/1
Template argument deduction is done by comparing each function template parameter type (call it P) with the type of the corresponding argument of the call (call it A) as described below

14.8.2.1/2
If P is not a reference type:
...
— If A is a cv-qualified type, the top level cv-qualifiers of A’s type are ignored for type deduction.

template-declaration:
  export_opt template < template-parameter-list > declaration
                                                      \--- 'void g(T& x)'

template-parameter-list:
  template-parameter
  template-parameter-list , template-parameter

template<class T> 
//             \---Template parameter
void g(T& x);
//        \-- Function parameter of a function template
//...
//
g<int>(v); // гипотетический вызов
//  \-------- Template argument

struct X {};

X const f();

template <class T>
    int g(T &);

int main()
{
    sizeof g(f());
}