Is lambdification of a concept an improvement or bad practice?

by

This shouldn’t be valid. The point of allowed lambdas into unevaluated contexts wasn’t to suddenly allow SFINAE on statements.

We do have some wording in [temp.deduct]/9 that makes this clear:

A lambda-expression appearing in a function type or a template parameter is not considered part of the immediate context for the purposes of template argument deduction. [Note: The intent is to avoid requiring implementations to deal with substitution failure involving arbitrary statements. [Example:

template <class T>
  auto f(T) -> decltype([]() { T::invalid; } ());
void f(...);
f(0);               // error: invalid expression not part of the immediate context

template <class T, std::size_t = sizeof([]() { T::invalid; })>
  void g(T);
void g(...);
g(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto h(T) -> decltype([x = T::invalid]() { });
void h(...);
h(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto i(T) -> decltype([]() -> typename T::invalid { });
void i(...);
i(0);               // error: invalid expression not part of the immediate context

template <class T>
  auto j(T t) -> decltype([](auto x) -> decltype(x.invalid) { } (t));   // #1
void j(...);                                                            // #2
j(0);               // deduction fails on #1, calls #2

— end example] — end note]

We just don’t have something equivalent for requirements. gcc’s behavior is really what you’d expect:

template <typename T> concept C = requires { []{ T t; }; };
struct X { X(int); };
static_assert(!C<X>); // ill-formed

Because the body of the lambda is outside of the immediate context, so it’s not a substitution failure, it’s a hard error.

More Related Contents:

  1. Why do we require requires requires?
  2. Does constraint subsumption only apply to concepts?
  3. C++ Concept that requires a member function with an OutputIterator as parameter
  4. In which access control context are concepts evaluated?
  5. Can I take the address of a function defined in standard library?
  6. What exactly are C++ modules?
  7. How to use source_location in a variadic template function?
  8. Will specialization of function templates in std for program-defined types no longer be allowed in C++20?
  9. Class type non-type template parameter initialization does not compile
  10. non-defaulted operator doesn’t generate == and != in C++20
  11. Why does aggregate initialization not work anymore since C++20 if a constructor is explicitly defaulted or deleted?
  12. Which headers in the C++ standard library are guaranteed to include another header?
  13. Will consteval functions allow template parameters dependent on function arguments?
  14. C++20 constexpr vector and string not working
  15. How to use std::views::transform on a vector?
  16. Ramifications of C++20 requiring two’s complement
  17. Why is volatile deprecated in C++20?
  18. Comparing 3 modern c++ ways to convert integral values to strings
  19. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  20. What is required for a custom BGL graph to work with topological sort?
  21. Is C++20 ‘char8_t’ the same as our old ‘char’?
  22. Range TS idioms and the mysterious auto &&
  23. asio How to change the executor inside an awaitable?
  24. Why does Clang 12 refuse to initialize aggregates in the C++20 way?
  25. Why C++ ranges “transform -> filter” calls transform twice for values that match the filter’s predicate?
  26. Why must a std::ranges::filter_view object be non-const for querying its elements?
  27. Why don’t I need to specify “typename” before a dependent type in C++20?
  28. Will consteval allow using static_assert on function arguments?
  29. if constexpr – why is discarded statement fully checked?
  30. if constexpr – why is discarded statement fully checked?

Leave a Comment