Generic lambda arity, C++ (vc++)

Language: Layout:

#include <type_traits>
#include <utility>

template <typename T>
struct mem_op_arity;

#define ARITY_REM_CTOR(...) __VA_ARGS__
#define ARITY_SPEC(cv, var)                                   \
template <typename C, typename R, typename... Args>           \
struct mem_op_arity<R (C::*) (Args... ARITY_REM_CTOR var) cv> : std::integral_constant<std::size_t, sizeof...(Args)> {};

ARITY_SPEC(const, (,...))
ARITY_SPEC(const, ())
ARITY_SPEC(, (,...))
ARITY_SPEC(, ())

#undef ARITY_SPEC

namespace detail {
	struct arbitrary {template <typename T> operator T&&();};
	template <std::size_t>
	using ignore = arbitrary;

template <typename L, std::size_t... Is,
	          typename U = decltype(std::declval<L>()(ignore<Is>{}...))>
	constexpr auto try_args(std::index_sequence<Is...>) {return sizeof...(Is);}

template <std::size_t I, typename L>
	constexpr auto arity_temp(int)
	  -> decltype(try_args<L>(std::make_index_sequence<I>{})) {
		return try_args<L>(std::make_index_sequence<I>{});}
	template <std::size_t I, typename L>
	constexpr std::enable_if_t<(I == 32), std::size_t> arity_temp(...) {
		return -1;}
	template <std::size_t I, typename L>
	constexpr std::enable_if_t<(I < 32), std::size_t> arity_temp(...) {
		return arity_temp<I+1, L>(0);}

template <typename L>
	constexpr typename mem_op_arity<L>::value_type arity(int) {return mem_op_arity<L>::value;}
	template <typename L>
	constexpr auto arity(...) {return arity_temp<0, L>(0);}
}

template <typename L>
constexpr std::size_t arity(L&& l) {return detail::arity<std::decay_t<L>>(0);}

#include <iostream>

int main() {
	std::cout << arity([] (auto a, int) -> void {std::cout << a.e;});
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,32 sec, absolute running time: 0,33 sec, absolute service time: 2,66 sec