If eval is invoked using argument deduction, the type for T will not contain references (l or r value). The type for T will contain references if the arguments are explicitly defined. Tested in clang 3.3 and gcc 4.7:
```c++
template<typename Type>
struct Invoke
{
    static Type&& apply(Type&& value)
    {
        return std::forward<int>(value);
    }    
};

template<typename Type>
Type eval(Type&& value)
{
    static_assert(std::is_reference<Type>::value, "not a reference");
    return Invoke<Type>::apply(std::forward<Type>(value));
}

int main()
{
    const int i = eval<const int&>(1); // compiles
    const int j = eval<int&&>(2);      // compiles
    const int k = eval(3);             // fails static assert
    int l = 4;
    
    return i + j + k + eval(l);        // fails on call to apply
}
```