Ticket #6915: substitution_failure_test.cpp

#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();
}