Concepts/SFINAE error with typename

Question

I'm trying to make a simply example for myself using new concept syntax. I decided to test if a type had operator() defined, and created a struct to test this using the SFINAE paradigm, but I'm running into type issues. Here is my code:

#include <utility>
#include <functional>

namespace Templates::Concepts {

    template<class type__>
    struct call_check {

        template<class type_ = type__>
        static auto check(std::nullptr_t) -> decltype(std::declval<type_>().operator()(), std::false_type(), std::true_type());

        template<class type_ = type__>
        static auto check(...) -> decltype(std::false_type());

        template<class type_ = type__>
        using type = decltype(check<type_>(nullptr));
    };

    template<typename type_>
    concept bool Callable = []() -> bool { typename call_check<type_>::type *t; return *t;};
}

I started without the 'typename' pointer, and just had

return call_check<type_>::type;,

but I received name-dependent type errors. After adding the typename I now receive

concepts.h:20:78: error: ‘typename Templates::Concepts::call_check<yes>::type’ names ‘template<class type_> using type = decltype (check<type_>(nullptr))’, which is not a type,

and I'm stuck. To be frank, I'm not completely sure what the most correct way is to implement this SFINAE check, so I'm not sure where to start. Any help with the paradigm and/or with concepts would also be appreciated.

I did see an example with something along the lines of

std::declval<type_>()(std::declval<other>(), std::declval<op>()), ...

replacing the first item in the decltype call of the first check (for binary operators), but I had difficulty understanding how that translated to a function call. (Third answer from the top, for reference: How to check whether operator== exists?).

Answer 1

With C++20 concept you can avoid "verbose and ugly" SFINAE paradigm.

Disclaimer: the following code is Gnu Concepts compatible (C++20 concept is not implemented yet).

Let's define the following concept which checks operator() existence on the type T:

template <typename T>
concept bool Callable() {
  return requires(T& t) {
    {t()}
  };
}

Now you can simply use it:

void bar(const Callable& t) {
  t();
}

GodBolt Complete Example.

---

Another solution can be obtained simply with std::is_invocable:

For example:

template <typename T>
struct Callable {
  static constexpr bool value = std::is_invocable_v<T>;
};

This is C++17 compatible.

Example here.

Answer 2

Let's tackle your original code:

template<class type__>

Double underscore anywhere is reserved to the implementation.

struct call_check {

    template<class type_ = type__>
    static auto check(std::nullptr_t) -> decltype(std::declval<type_>().operator()(), std::false_type(), std::true_type());

You usually don't want to check whether something has an operator(); you want to check if it's callable with no arguments, and there's no point in the , std::false_type() part, so the trailing return type should be

-> decltype(std::declval<type_>()(), std::true_type())

   template<class type_ = type__>
   static auto check(...) -> decltype(std::false_type());

This is unnecessarily verbose. decltype(std::false_type()) is just std::false_type. There's also no need for the default template argument, since you aren't using it, thus it becomes

    template<class> 
    static std::false_type check(...);

   template<class type_ = type__>
   using type = decltype(check<type_>(nullptr));

And here there's no reason to make this an alias template. It should be just an alias:

using type = decltype(check<type__>(nullptr)); // modulo reserved identifier.

};

template<typename type_>
concept bool Callable = []() -> bool { typename call_check<type_>::type *t; return *t;};

This is wrong in many ways. A variable concept in the TS must be initialized with a constant expression, and lambdas can't be used in constant expressions before C++17. Moreover, you didn't call the lambda, so you are implicitly converting it to a function pointer and then to bool, which always yields true. Finally, actually calling the lambda would be undefined behavior, because it dereferences an uninitalized pointer.

The simplest way to spell this is

 template<typename type_>
 concept bool Callable = call_check<type_>::type::value;