Enable a non-template member function iff it would typecheck

c++, c++-templates, c++11, sfinae

Solution

You can make `baz` a template, such that if the return type is invalid the member will be SFINAE-d out rather than result in a hard error:

template <class T1, class T2>
class foo
{
    T1 t1;
    T2 t2;

    T1 bar(); //Always exists

    template<typename T = T1>
    decltype(std::declval<T&>()(t2)) baz();
};

The `T` parameter is necessary to make the computed expression type-dependent, or else SFINAE doesn't apply. If you're worried that this implementation detail 'leaks' out and that someone might attempt `f.baz<int>()`, you can declare `baz` with `template<typename... Dummy, typename T = T1>` and enforce proper usage with e.g. `static_assert( sizeof...(Dummy) == 0, "Incorrect usage" );` in the function body. Both approaches do make it harder to take the address of the member: it should look like e.g. `&foo<T, U>::baz<>`.

Another approach is to introduce a class template specialization:

template<typename...> struct void_ { using type = void; };

template<typename T1, typename T2, typename = void>
class foo {
    // version without baz
};

template<typename T1, typename T2>
class foo<T1, T2, typename void_<decltype(std::declval<T1&>()(std::declval<T2>()))>::type> {
    decltype(std::declval<T1&>()(std::declval<T2>())) baz();
};

In this case `&foo<T, U>::baz` is fine for taking the address of the member (assuming it is present of course). Code that is common to both specialization can be factored out in a common base, and if there is a worry that the additional template parameter that is introduced as an implementation detail might leak it is possible to have a 'real' `foo` taking only two template parameters in turn inheriting from such an implementation.

Problem

Original source