struct singleton {
   singleton() = delete;
   singleton(singleton&) = delete;
   singleton(const singleton&) = delete;
   singleton(singleton&&) = delete;
   singleton(const singleton&&) = delete;
};

struct test2 {
   int helloworld(singleton&);
};
struct Hello
{
   int helloworld(double, double, int, int, int) { return 0; }
   int helloworld(double, double) { return 0; }
   int helloworld(double) { return 0; }
};



struct Generic {};    

template<typename U>
struct tag {
   template<typename T>
   operator T&() & {
       return std::declval();
   }
   template<typename T>
   operator T() && {
       return std::declval();
   }
};

template<typename WhereIs, typename, typename ...T>
struct has_hello_world : std::false_type {};

template<typename WhereIs, typename ...T>
struct has_hello_world<WhereIs, std::void_t<decltype(std::declval().helloworld(std::declval<std::add_lvalue_reference_t<tag>>()...))>, T...> : std::true_type {};

template<typename WhereIs, typename T>
constexpr bool test_impl(tag)…

struct Base {
   void kek();
};

template <typename T>
struct Helper : public T, public Base {
};

void AcceptBaseMethod(void (Base::*)());

template <typename T>
std::false_type Check(T value, std::void_t<decltype(AcceptBaseMethod(&T::kek))>* = nullptr);
std::true_type Check(...);

template <typename T>
inline constexpr bool kHasKek = decltype(Check(std::declval<Helper>()))::value;


// tests
struct HasKek {
   void kek(int);
};

struct Empty {
};

struct HasOverloadedKek {
   void kek(int);
   void kek();
};

struct HasAmbigousKek {
   void kek(int);
   void kek(std::string);
};

struct HasTemplateKek {
   template <typename ...Args>
   void kek(Args...);
};

static_assert(kHasKek);
static_assert(!kHasKek);
static_assert(kHasKek);
static_assert(kHasKek);
static_assert(kHasKek);