Detecting existence of a class member I wanted to detect if I have a member in a simple POD struct and after some searching and merging some methods I found on the web I've come up with this solution:

#include &lt;iostream&gt;

template&lt;class...Fs&gt;
struct funcs_t{};

template&lt;class F0, class...Fs&gt;
struct funcs_t&lt;F0, Fs...&gt;: F0, funcs_t&lt;Fs...&gt; {
    funcs_t(F0 f0, Fs... fs):
    F0(std::move(f0)), funcs_t&lt;Fs...&gt;(std::move(fs)...)
    {}
    using F0::operator();
    using funcs_t&lt;Fs...&gt;::operator();
};

template&lt;class F&gt;
struct funcs_t&lt;F&gt;:F {
    funcs_t(F f) : F(std::move(f)) {};
    using F::operator();
};

template&lt;class...Fs&gt;
funcs_t&lt;std::decay_t&lt;Fs&gt;...&gt; funcs(Fs&amp;&amp;...fs) {
    return {std::forward&lt;Fs&gt;(fs)...};
}

#define HAS_MEMBER(cls, memb)\
    [](){\
        auto with_memb = [](auto &amp;&amp;A, int x)\
                -&gt; decltype(typename std::remove_reference&lt;decltype(A)&gt;::type().memb, std::true_type())\
        {\
            return std::true_type();\
        };\
        auto with_no_memb = [](auto &amp;&amp;A, float x) -&gt; std::false_type {\
            return std::false_type();\
        };\
        auto has_memb = funcs(with_memb, with_no_memb);\
        return has_memb(cls(), 1);\
    }()

struct A {
    int a;
    int b;
};

int main(int argc, char const *argv[])
{
    std::cout &lt;&lt; HAS_MEMBER(A, b) &lt;&lt; std::endl;
    return 0;
}
Your detector fails in the face of overloading and templating. Also, it will only detect (static) member-variables and (static) member-functions. While you can extend it to types (and type-aliases), accepting templates and overloading would need better language-provided reflection-facilities.

Anyway, pure existence is generally uninteresting, supported operations count.
funcs() and funcs_t are nearly a generally useful abstraction.

Just use perfect forwarding instead of by-value and std::move(). Allowing for all callables, including final classes, function-pointers, member-function-pointers, and the same wrapped in a std::reference_wrapper would admittedly add significant amounts of code.

A good name would be overloaded.
HAS_MEMBER needlessly depends on default-constructing the passed class. Fix that by using decltype, std::declval() and unevaluated contexts.
If you don't use an argument, don't name it. Specifically for main(), just don't ask for it.
Don't use std::endl. In the rare cases you actually need to flush manually, be explicit and use std::flush. Nearly always you are just crippling performance.
return 0; is implicit for main(). Make of that what you will.