#include <iostream>

//#define BOOST_RESULT_OF_USE_DECLTYPE 1

#include <boost/fusion/container.hpp>
#include <boost/fusion/support.hpp>
#include <boost/fusion/functional.hpp>


template<typename T> struct subst_failure_if_not_int {};
template<> struct subst_failure_if_not_int<int> { typedef int type; };

template<typename T>
typename subst_failure_if_not_int<T>::type
dispatch_int(int) {
	/* this overload is eliminated when substitution failure occurs */
	std::cout << "called int version\n";
	return 0;
}

template<typename T>
void
dispatch_int(long) {
	/* this is fallback overload */
	std::cout << "called default version\n";
}

void test1() {
	dispatch_int<int> (0); // prints "called int version"
	dispatch_int<float> (0); // prints "called default version"
}


/* now, exactly the same approach applied to boost::fusion::invoke */

struct F {
	template<class> struct result {};
	template<class F> struct result<F(float)> { typedef int type; };
	int operator()(float) { std::cout << "invoked F(float)\n"; }
};


template<class F, class Sequence>
typename boost::fusion::result_of::invoke<F, Sequence>::type
try_invoke(int) {
	std::cout << "called invoke()-ing overload\n";
	return boost::fusion::invoke(F(), Sequence());
}

template<class F, class Sequence>
void
try_invoke(long) {
	std::cout << "called fallback overload\n";
}

struct junk { int i; };

void test2() {
	// fails to compile under MSVC 9,
	// compiles and works as intended under GCC 4.6 when BOOST_RESULT_OF_USE_DECLTYPE enabled,
	// fails to compile under GCC 4.6 with decltype() usage disabled:
	try_invoke<F, boost::fusion::vector<float>> (0);
	
	// fails to compile in all tested cases, while should be selecting fallback overload:
	try_invoke<F, boost::fusion::vector<junk>> (0);
}


int main() {
	test1();
	test2();
}