fork(3) download

copy

#include <iostream>
#include <type_traits>
#include <string>
using namespace std;
 
struct A {};
struct B {};
struct C {};
struct D {};
struct E {};
 
template <typename H>
auto foo (H h, enable_if_t<
  is_same<typename result_of<H(A)>::type, bool>::value>* = 0)
{
	return [h] (B x) { return h (A {}); };
}
 
template <typename H>
auto foo (H h, enable_if_t<
  is_same<typename result_of<H(B)>::type, bool>::value>* = 0)
{
	return [h] (C x) { return h (B {}); };
}
 
template <typename H>
auto foo (H h, enable_if_t<
  is_same<typename result_of<H(C)>::type, bool>::value>* = 0)
{
	return [h] (D x) { return h (C {}); };
}
 
template <typename H>
auto foo (H h, enable_if_t<
  is_same<typename result_of<H(D)>::type, bool>::value>* = 0)
{
	return [h] (E x) { return h (D {}); };
}
 
#include <boost/utility/result_of.hpp>
#include <boost/type_traits.hpp>
 
template <typename Stop, typename Handler, typename Result>
struct call_until_helper
{
	call_until_helper (Handler)
	{
	}
};
 
template <typename Stop, typename Handler>
call_until_helper<Stop, Handler,
  typename boost::function_traits<Handler>::result_type>
call_until (Handler handler)
{
	return call_until_helper<Stop, Handler,
	  typename boost::function_traits<Handler>::result_type> (handler);
}
 
int main ()
{
	auto inner_handler = [] (A) -> bool { return false; };
 
	// auto f = foo (foo (foo (foo ( inner_handler ))));
	auto f = call_until<E> ( inner_handler );
 
	std::cout << f (E {}) << "\n";
}

In file included from /usr/include/boost/type_traits.hpp:27:0,
                 from prog.cpp:41:
/usr/include/boost/type_traits/function_traits.hpp: In instantiation of 'struct boost::function_traits<main()::<lambda(A)> >':
prog.cpp:54:1:   required by substitution of 'template<class Stop, class Handler> call_until_helper<Stop, Handler, typename boost::function_traits<Handler>::result_type> call_until(Handler) [with Stop = E; Handler = main()::<lambda(A)>]'
prog.cpp:65:41:   required from here
/usr/include/boost/type_traits/function_traits.hpp:168:8: error: invalid use of incomplete type 'struct boost::detail::function_traits_helper<main()::<lambda(A)>*>'
 struct function_traits : 
        ^
/usr/include/boost/type_traits/function_traits.hpp:21:36: error: declaration of 'struct boost::detail::function_traits_helper<main()::<lambda(A)>*>'
 template<typename Function> struct function_traits_helper;
                                    ^
prog.cpp: In function 'int main()':
prog.cpp:65:41: error: no matching function for call to 'call_until(main()::<lambda(A)>&)'
  auto f = call_until<E> ( inner_handler );
                                         ^
prog.cpp:65:41: note: candidate is:
prog.cpp:54:1: note: template<class Stop, class Handler> call_until_helper<Stop, Handler, typename boost::function_traits<Handler>::result_type> call_until(Handler)
 call_until (Handler handler)
 ^
prog.cpp:54:1: note:   substitution of deduced template arguments resulted in errors seen above

Standard output is empty