////////////////////////////////////////////////////////////////////////////////////////////////////
// main.cpp
//
//  Copyright 2012 Eric Niebler. 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 <utility>
#include <type_traits>

#define ENABLE_IF(...)                                                                  \
    typename std::enable_if<static_cast<bool>(__VA_ARGS__)>::type *& = enabler

extern void *enabler;

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

////////////////////////////////////////////////////////////////////////////////////////
// sfinae_error
template<typename Sig>
struct sfinae_error;

template<typename Fun, typename ...Args>
struct sfinae_error<Fun(Args...)>
{
    virtual sfinae_error what() const noexcept
    {
        typedef decltype(std::declval<Fun>()(std::declval<Args>()...)) type;
        return *this;
    }
};

template<typename T>
void void_(T const &);

////////////////////////////////////////////////////////////////////////////////////////
// Many thanks to Paul Fultz for the ideas behind the unsfinae function wrapper
template<typename Sig, typename Enable = void>
struct is_callable
  : std::false_type
{};

template<typename Fun, typename ...Args>
struct is_callable<
    Fun(Args...)
  , decltype(void_(std::declval<Fun>()(std::declval<Args>()...)))
>
  : std::true_type
{};

template<typename Fun>
struct try_call
{
    template<typename ...Args, ENABLE_IF(is_callable<Fun(Args...)>::value)>
    auto operator()(Args &&...args) const
    RETURN(
        Fun()(static_cast<Args &&>(args)...)
    )

    template<typename ...Args, ENABLE_IF(!is_callable<Fun(Args...)>::value)>
    auto operator()(Args &&...) const
    RETURN(
        sfinae_error<Fun(Args...)>()
    )
};

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

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

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

struct foo
{};

int main()
{
    int i = S2()(32);
    auto x = S2()(foo());
}