/*=============================================================================
    Copyright (c) 2012 Paul Fultz II
    sfinae_error.cpp
    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/


#include <cstdio>
#include <utility>
#include <initializer_list>

template<class F>
struct is_callable {};

template<class F, class... Args>
struct is_callable<F(Args...)>
{
    typedef char yes; 
    typedef long no; 
    template<class T> 
    struct selector {}; 

    template<class U> 
    static yes check( selector<decltype( std::declval<U>()(std::declval<Args>()...) )> * ); 

    template<class U> 
    static no check(...); 
    
    static const bool value = sizeof(check<F>(0)) == sizeof(yes); 

    typedef std::integral_constant<bool, value> type; 
};



#define RETURN(...) -> decltype(__VA_ARGS__) { return __VA_ARGS__; } 

template<class F>
struct sfinae_error
{

    template<class X, class Enable = void>
    struct result
    {
        typedef void type;
    };

    template<class X, class... T>
    struct result<X(T...), typename std::enable_if<is_callable<X(T...)>::value>::type>
    {
        typedef decltype(F()(std::declval<T>()...)) type;
    };

    template<class... T>
    typename result<F(T&&...)>::type operator()(T &&... x)
    {
        return F()(std::forward<T>(x)...);
    }
};


struct S0_sfinae {
    template<typename T>
    auto operator()(T t) const RETURN( t + 1 )
};

typedef sfinae_error<S0_sfinae> S0;

struct S1 {
    template<typename T>
    auto operator()(T t) const RETURN( S0()(t) )
};

struct S2 {
    template<typename T>
    auto operator()(T t) const RETURN( S1()(t) )
};

struct foo {};

int main()
{
    int i = S2()(42);
    printf("%i\n", i);

    S2()(foo());
}