How would I go about testing if a lambda is stateless, that is, if it captures anything or not? My guess would be using overload resolution with a function pointer overload, or template specialization?
int a; auto l1 = [a](){ return 1; }; auto l2 = [](){ return 2; }; // test l1 and l2, get a bool for statelessness. As per the Standard, if a lambda doesn't capture any variable, then it is implicitly convertible to function pointer.
Based on that, I came up with is_stateless<> meta-function which tells you whether a lambda is stateless or not.
#include <type_traits> template <typename T, typename U> struct helper : helper<T, decltype(&U::operator())> {}; template <typename T, typename C, typename R, typename... A> struct helper<T, R(C::*)(A...) const> { static const bool value = std::is_convertible<T, R(*)(A...)>::value; }; template<typename T> struct is_stateless { static const bool value = helper<T,T>::value; }; And here is the test code:
int main() { int a; auto l1 = [a](){ return 1; }; auto l2 = [](){ return 2; }; auto l3 = [&a](){ return 2; }; std::cout<<std::boolalpha<<is_stateless<decltype(l1)>::value<< "\n"; std::cout<<std::boolalpha<<is_stateless<decltype(l2)>::value<< "\n"; std::cout<<std::boolalpha<<is_stateless<decltype(l3)>::value<< "\n"; } Output:
false true false #include <type_traits> // std::true_type, std::false_type #include <utility> // std::declval template<typename Lambda> auto is_captureless_lambda_tester(int) -> decltype( +std::declval<Lambda>(), void(), std::true_type {} ); template<typename Lambda> auto is_captureless_lambda_tester(long) -> std::false_type; template<typename Lambda> using is_captureless_lambda = decltype( is_captureless_lambda_tester<Lambda>(0) ); Does not work for polymorphic lambdas, require as a precondition that the argument be a closure type. (E.g. is_captureless_lambda<int> is std::true_type.)
Per § 5.1.2/6
The closure type for a non-generic lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function with C ++ language linkage (7.5) having the same parameter and return types as the closure type’s function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type’s function call operator. For a generic lambda with no lambda-capture, the closure type has a public non-virtual non-explicit const conversion function template to pointer to function.
If it's convertible to a pointer to function, then MAYBE it has to not capture anything (stateless). In action:
int v = 1; auto lambda1 = [ ]()->void {}; auto lambda2 = [v]()->void {}; using ftype = void(*)(); ftype x = lambda1; // OK ftype y = lambda2; // Error You can also use std::is_convertible:
static_assert(is_convertible<decltype(lambda1), ftype>::value, "no capture"); static_assert(is_convertible<decltype(lambda2), ftype>::value, "by capture"); An option could be to explicitly look a the size of the type, a stateless should in principle have the same size as other stateless types (I picked std::true_type for a reference type).
#include<cassert> #include<type_traits> template<class T> struct is_stateless_lambda : std::integral_constant<bool, sizeof(T) == sizeof(std::true_type)>{}; int main(){ auto l1 = [a](){ return 1; }; auto l2 = [](){ return 2; }; auto l3 = [&a](){ return 2; }; assert( boost::is_stateless_lambda<decltype(l1)>::value == false ); assert( boost::is_stateless_lambda<decltype(l2)>::value == true ); assert( boost::is_stateless_lambda<decltype(l3)>::value == false ); } I don't know how portable this solution is. In any case check my other solution: https://stackoverflow.com/a/34873139/225186
Boost.TypeTraits is_stateless seems to do the job for whatever reason without much drama:
#include<boost/type_traits.hpp> #include<cassert> int main(){ auto l1 = [a](){ return 1; }; auto l2 = [](){ return 2; }; auto l3 = [&a](){ return 2; }; assert( boost::is_stateless<decltype(l1)>::value == false ); assert( boost::is_stateless<decltype(l2)>::value == true ); assert( boost::is_stateless<decltype(l3)>::value == false ); } boost::is_stateless is simple the combination of other conditions, it can be expressed in terms of standard type traits I suppose:
::boost::is_stateless = ::boost::has_trivial_constructor<T>::value && ::boost::has_trivial_copy<T>::value && ::boost::has_trivial_destructor<T>::value && ::boost::is_class<T>::value && ::boost::is_empty<T>::value Check my other answer based on sizeof: https://stackoverflow.com/a/34873353/225186