Lambda expressions as class template parameters

by

As of C++20, this answer is now outdated. C++20 introduces stateless lambdas in unevaluated contexts1:

This restriction was originally designed to prevent lambdas from appearing in signatures, which would have opened a can of worm for mangling because lambdas are required to have unique types. However, the restriction is much stronger than it needs to be, and it is indeed possible to achieve the same effect without it

Some restrictions are still in place (e.g. lambdas still can’t appear on function signatures), but the described usecase is now completely valid and the declaration of a variable is no longer necessary.

I’m asking if you can do something like:

Foo<decltype([]()->void { })> foo;

No you can’t, because lambda expressions shall not appear in an unevaluated context (such as decltype and sizeof, amongst others).
C++0x FDIS, 5.1.2 [expr.prim.lambda] p2

The evaluation of a lambda-expression results in a prvalue temporary (12.2). This temporary is called the
closure object. A lambda-expression shall not appear in an unevaluated operand (Clause 5). [ Note: A
closure object behaves like a function object (20.8).—end note ]
(emphasis mine)

You would need to first create a specific lambda and then use decltype on that:

auto my_comp = [](const std::string& left, const std::string& right) -> bool {
  // whatever
}

typedef std::unordered_map<
  std::string,
  std::string,
  std::hash<std::string>,
  decltype(my_comp)
  > map_type;

That is because each lambda-derived closure object could have a completely different type, they’re like anonymous functions after all.

More Related Contents:

  1. C++11 does not deduce type when std::function or lambda functions are involved
  2. How to convert a lambda to an std::function using templates
  3. Can lambda functions be templated?
  4. Passing a lambda into a function template
  5. Specializing a template on a lambda in C++0x
  6. Lambdas and std::function
  7. Check if a class has a member function of a given signature
  8. Variadic template pack expansion
  9. Why does C++11’s lambda require “mutable” keyword for capture-by-value, by default?
  10. std::function vs template
  11. How to capture a unique_ptr into a lambda expression?
  12. initializer_list and template type deduction
  13. Is constexpr supported with lambda functions / expressions?
  14. Matching alias template as template argument
  15. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  16. How do compilers treat variable length arrays
  17. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  18. void_t “can implement concepts”?
  19. How can I output the value of an enum class in C++11
  20. How Does std::enable_if work?
  21. How to pass a template function in a template argument list
  22. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  23. What is the lifetime of a C++ lambda expression?
  24. Returning a void?
  25. What is the purpose of std::function and how to use it?
  26. In lambda functions syntax, what purpose does a ‘capture list’ serve?
  27. How does std::forward receive the correct argument?
  28. Why can’t I use alias from a base class in a derived class with templates?
  29. Explicit Return Type of Lambda
  30. Overload resolution with std::function

Leave a Comment