Compiler Explorer

Source code

#include <cassert>

#define TEST 1

template<class T, class U>
auto f(T t, U u)
{
    if constexpr (requires { t*2; }) return t*2;
    else if constexpr (requires { u*2; }) return u*2;
}

#if TEST
// Your challenge: Make the code of `g` simpler.
// Ideally, use a fold-expression inside `g`.
template<class T, bool = requires (T t) { t*2; }>
struct X {
    X(T&) {}
    void go() const {}
};
template<class T>
struct X<T, true> {
    T& t_;
    X(T& t) : t_(t) {}
    decltype(auto) go() const { return t_*2; }    
};
template<class T> auto operator+(X<T, true> x, auto) { return x; }
template<class T> auto operator+(X<T, false>, auto x) { return x; }

template<class... Ts>
auto g(Ts... ts)
{
    return (X<decltype(ts)>(ts) + ... + 0).go();
}
#endif

struct A { auto operator*(int) const { return nullptr; } };

int main()
{
    assert(f(1, A()) == 2);
    assert(f(A(), 1) == nullptr);
    assert(f(1, "1") == 2);
    assert(f("1", 1) == 2);

#if TEST
    assert(g(1) == 2);
    assert(g(1, A()) == 2);
    assert(g(A()) == nullptr);
    assert(g(A(), 1) == nullptr);
    assert(g(1, "1") == 2);
    assert(g("1", 1) == 2);
    assert(g("1", "2", "3", 1) == 2);
    assert(g("1", "2", "3", A(), 1) == nullptr);
#endif
}