#ifndef BOOST_PP_IS_ITERATING
//////////////////////////////////////////////////////////////////////////////
//  Copyright 20011 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)

#ifndef CURRYABLE_HPP
#define CURRYABLE_HPP

#include <cstddef>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/comparison/less_equal.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/selection/max.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>

#ifndef CURRY_MAX_FN_ARITY
#define CURRY_MAX_FN_ARITY 10
#endif

template<typename Fun, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(CURRY_MAX_FN_ARITY, typename Arg, void), typename Dummy = void >
struct is_callable_with;

template<typename Fun, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_DEC(CURRY_MAX_FN_ARITY), typename Arg, void), typename Dummy = void >
struct curryable;

template<std::size_t Size>
struct sizer
{
    typedef char (&type)[Size];
};

struct invalid_type
{
    friend invalid_type operator,(invalid_type, int);
};

template<typename T>
sizer<2>::type is_invalid(T const &);
sizer<1>::type is_invalid(invalid_type const &);

struct any
{
    template<typename T>
    any(T const &);
};

template<typename Fun>
struct callable_wrap
  : Fun
{
#define M0(Z, N, D)                                                                                 \
    typedef invalid_type (*BOOST_PP_CAT(function_type, N))(                                         \
        BOOST_PP_ENUM_PARAMS_Z(Z, N, any BOOST_PP_INTERCEPT));                                      \
    operator BOOST_PP_CAT(function_type, N)() const volatile;                                       \
    /**/
    BOOST_PP_REPEAT(CURRY_MAX_FN_ARITY, M0, ~)
#undef M0
};

#define M0(Z, N, D) static BOOST_PP_CAT(Arg, N) & BOOST_PP_CAT(arg, N);
#define BOOST_PP_LOCAL_MACRO(N)                                                                     \
    template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >                          \
    struct is_callable_with<Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, Arg) >                             \
    {                                                                                               \
        static callable_wrap<Fun> &fun;                                                             \
        BOOST_PP_REPEAT(N, M0, ~)                                                                   \
        static bool const value =                                                                   \
            bool(sizeof(is_invalid((fun(BOOST_PP_ENUM_PARAMS(N, arg)), 0)))-1);                     \
        typedef boost::mpl::bool_<value> type;                                                      \
    };                                                                                              \
    /**/
#define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(CURRY_MAX_FN_ARITY))
#include BOOST_PP_LOCAL_ITERATE()
#undef M0

template<typename Fun, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(CURRY_MAX_FN_ARITY, typename Arg, void), typename Enable = void>
struct is_natively_callable_with
  : is_callable_with<Fun BOOST_PP_ENUM_TRAILING_PARAMS(CURRY_MAX_FN_ARITY, Arg)>
{};

template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(CURRY_MAX_FN_ARITY, typename Arg) >
struct is_natively_callable_with<curryable<Fun> BOOST_PP_ENUM_TRAILING_PARAMS(CURRY_MAX_FN_ARITY, Arg), void>
  : is_natively_callable_with<Fun BOOST_PP_ENUM_TRAILING_PARAMS(CURRY_MAX_FN_ARITY, Arg) >
{};

#define BOOST_PP_LOCAL_MACRO(N) \
    template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), typename B) > \
    struct is_natively_callable_with<curryable<Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, A)> BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B), typename boost::disable_if<boost::is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), void> >::type> \
      : is_natively_callable_with<Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B) > \
    {};\
    /**/
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_PP_DEC(CURRY_MAX_FN_ARITY))
#include BOOST_PP_LOCAL_ITERATE()

#define BOOST_PP_ITERATION_PARAMS_1 (4, (0, BOOST_PP_DEC(CURRY_MAX_FN_ARITY), "curryable.hpp", 1))
#include BOOST_PP_ITERATE()

#endif

#else
#if BOOST_PP_ITERATION_FLAGS() == 1

#define N BOOST_PP_ITERATION()

template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >
struct curryable<Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, Arg) >
{
    Fun fun;
#define M0(Z, N, D) BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(arg, N);
    BOOST_PP_REPEAT(N, M0, ~)
#undef M0

#if N == 0
    explicit curryable(Fun f = Fun())
      : fun(f)
    {}
#else
#define M0(Z, N, D) BOOST_PP_CAT(arg, N)(BOOST_PP_CAT(a, N))
    curryable(Fun f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, Arg, a))
      : fun(f) BOOST_PP_ENUM_TRAILING(N, M0, ~)
    {}
#undef M0
#endif

    template<typename Sig>
    struct result;

    template<typename This>
    struct result<This()>
    {
        typedef curryable type;
    };

    curryable operator()() const
    {
        return *this;
    }

#if BOOST_PP_LESS_EQUAL(1, BOOST_PP_DEC(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N)))
#define BOOST_PP_ITERATION_PARAMS_2 (4, (1, BOOST_PP_DEC(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N)), "curryable.hpp", 2))
#include BOOST_PP_ITERATE()
#endif

    template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), typename B)>
    struct result<This(BOOST_PP_ENUM_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B))>
      : boost::result_of<Fun(BOOST_PP_ENUM_PARAMS(N, Arg) BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B))>
    {};

    template<BOOST_PP_ENUM_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), typename B)>
    typename boost::result_of<Fun(BOOST_PP_ENUM_PARAMS(N, Arg) BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B))>::type
    operator()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), B, const & b)) const
    {
        return fun(BOOST_PP_ENUM_PARAMS(N, arg) BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(BOOST_PP_SUB(CURRY_MAX_FN_ARITY, N), b));
    }
};

#undef N

#else

#define X BOOST_PP_ITERATION_1
#define Y BOOST_PP_ITERATION_2

    template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(Y, typename B) >
    struct result<This(BOOST_PP_ENUM_PARAMS(Y, B))>
      : boost::mpl::eval_if<
            is_natively_callable_with<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B) >
          , boost::result_of<Fun(BOOST_PP_ENUM_PARAMS(X, Arg) BOOST_PP_COMMA_IF(X) BOOST_PP_ENUM_PARAMS(Y, B))>
          , boost::mpl::identity<curryable<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B) > >
        >
    {};

    template<BOOST_PP_ENUM_PARAMS(Y, typename B) >
    typename boost::lazy_enable_if<is_natively_callable_with<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B) >, boost::result_of<Fun(BOOST_PP_ENUM_PARAMS(X, Arg) BOOST_PP_COMMA_IF(X) BOOST_PP_ENUM_PARAMS(Y, B))> >::type
    operator()(BOOST_PP_ENUM_BINARY_PARAMS(Y, B, const & b)) const
    {
        return fun(BOOST_PP_ENUM_PARAMS(X, arg) BOOST_PP_COMMA_IF(X) BOOST_PP_ENUM_PARAMS(Y, b));
    }

    template<BOOST_PP_ENUM_PARAMS(Y, typename B) >
    typename boost::disable_if<is_natively_callable_with<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B) >, curryable<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B) > >::type
    operator()(BOOST_PP_ENUM_BINARY_PARAMS(Y, B, const & b)) const
    {
        return curryable<curryable BOOST_PP_ENUM_TRAILING_PARAMS(Y, B)>(*this BOOST_PP_ENUM_TRAILING_PARAMS(Y, b));
    }

#undef X
#undef Y

#endif
#endif