template<class T, std::enable_if_t<!std::is_reference<T>::value, bool> = true>
using rval = T;

template<class T>
void f(rval<T>&&)
{
    std::cout << "rvalue_reference\n";
}

template<class T>
void f(T&)
{
    std::cout << "lvalue_reference\n";
}


int main()
{
    int i = 0;
    f(0);
    f(i);
}

NB>>>>>template<class T, std::enable_if_t<!std::is_reference<T>::value, bool> = true>
NB>>>>>using rval = T;
__>>>>...
NB>>>>>

template<class T, std::enable_if_t<!std::is_reference<T>::value, bool> = true>
using rval = T;

__>template<class T, std::enable_if_t<!std::is_reference<T>::value, bool> = true>
__>using rval = T;
__>

template<typename T>
using owner = T;

void foo(gsl::owner<int*> data);

#include <iostream>
using namespace std;

template<class T> using ptr = T*;

template<class T> 
void foo(ptr<T> p) { cout << __PRETTY_FUNCTION__ << endl; }

int main() {
    int x = 1;
    foo(&x);
//  foo(x);  // will not compile
}

NB>template<class T, std::enable_if_t<!std::is_reference<T>::value, bool> = true>
NB>using rval = T;

template<class T, std::enable_if_t<CONDITION_GOES_HERE, ANY_SIMPLE_TYPE> V = ANY_SIMPLE_VALUE>  // bool = true, int = 12345 и т.п.
using checked = T;

template<class T> struct foo { using bar = T*; };
template<class T> using foobar = foo<T>::bar;

template<class T> void buz(foobar<T> t) {}

int main() {
  buz<int>(nullptr_t); // void(int*)

  int x;
  buz(&x);  // int* = foobar<T> = foo<T>::bar - сопоставление зависимых имён
            // foo<T>::bar = T* - это если нам повезло, C++17+ и нет специализаций foo.
            // T = int
}

template<class T> using foobar = T*;
...
buz(&x);  // int* = T*

template<class T,
         class V = std::enable_if_t<sizeof(T)==1>, // void в случае успеха
         std::enable_if_t<sizeof(T)==1, int> I = 123 // int в случае успеха,
        >
void foo(T b) {}

template<class T>
void bar(T b, std::enable_it_t<sizeof(T)==1,int> i = 123) {}

foo('a');  // тут всё на SFINAE
foo<long,char,456>(1U);  // ни в склад, ни в лад!

bar('a');  // тут всё как задумано
bar('a', 0xDEADC0DE);  // SFINAE будет работать, но мы изменили тип функции и сделали дырку в синтаксисе - позволяем вызывать с лишним аргументом

template<class T, class V> using itself_t = T;
template<class T, int   I> using itself_i = T;

template<class T> void buz(itself_t<T, std::enable_if_t<sizeof(T)==1>         > b) {}
template<class T> void xyz(itself_i<T, std::enable_if_t<sizeof(T)==1,int>(123)> b) {}

template<class T, class V = std::enable_if_t<sizeof(T)==1> > using somebyte_t = T;
template<class T, std::enable_if_t<sizeof(T)==1,int> I = 1 > using somebyte_i = T;

template<class T> void ttt(somebyte_t<T> b);
template<class T> void iii(somebyte_i<T> b);