Proposal: support non-structural typing (e.g. new user-defined base-types, or some form of basic nominal typing). This allows programmer to have more refined types supporting frequently used idioms...

void f(int, float);
double bar(int, float);
auto foo(int) {
   return 5;
}

// type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

struct never {};

template<typename T> struct return_type_impl {
 using type = never;
};

template<typename ret, typename ... args> struct return_type_impl<ret(args...)> {
 using type = ret;
};


template<typename T> using return_type = typename return_type_impl<T>::type;

static_assert(__is_same(return_type<decltype(f)>, void));
static_assert(__is_same(return_type<decltype(bar)>, double));
static_assert(__is_same(return_type<decltype(foo)>, int));
static_assert(__is_same(return_type<int>, never));