#include "boost/spirit/phoenix/functions.hpp"
#include "boost/spirit/phoenix/operators.hpp"
#include "boost/spirit/phoenix/primitives.hpp"
#include "boost/spirit/phoenix/statements.hpp"
#include "boost/function.hpp"

namespace phoenix
{
    template <typename SigT>
    struct placeholder_types;

    template <typename RT>
    struct placeholder_types<RT()>
    {
        typedef RT result_type;
        typedef tuple<> args_type;
        typedef boost::function<RT(args_type const&)> function_type;

        static args_type const&
        convert_args(args_type const& args)
        { return args; }

        template <typename TupleT>
        static args_type
        convert_args(TupleT const& args)
        { return args_type(); }
    };

    template <typename RT, typename Arg0>
    struct placeholder_types<RT(Arg0)>
    {
        typedef RT result_type;
        typedef tuple<Arg0&> args_type;
        typedef boost::function<RT(args_type const&)> function_type;

        static args_type const&
        convert_args(args_type const& args)
        { return args; }

        template <typename TupleT>
        static args_type
        convert_args(TupleT const& args)
        { return args_type(args[tuple_index<0>()]); }
    };

    template <typename RT, typename Arg0, typename Arg1>
    struct placeholder_types<RT(Arg0, Arg1)>
    {
        typedef RT result_type;
        typedef tuple<Arg0&, Arg1&> args_type;
        typedef boost::function<RT(args_type const&)> function_type;

        static args_type const&
        convert_args(args_type const& args)
        { return args; }

        template <typename TupleT>
        static args_type
        convert_args(TupleT const& args)
        { return args_type(args[tuple_index<0>()], args[tuple_index<1>()]); }
    };

    template <typename DerivedT, typename SigT>
    struct placeholder_eval
    {
        template <typename TupleT>
        struct result
        {
            typedef typename placeholder_types<SigT>::result_type type;
        };

        DerivedT& derived()
        { return static_cast<DerivedT&>(*this); }

        DerivedT const& derived() const
        { return static_cast<DerivedT const&>(*this); }

        template <typename TupleT>
        typename actor_result<placeholder_eval, TupleT>::type
        eval(TupleT const& args) const
        {
            return this->derived().f(
                placeholder_types<SigT>::convert_args(args));
        }
    };

    template <typename ActorT>
    struct placeholder_ftor
    {
        placeholder_ftor(ActorT const& actor_)
        : actor(actor_) {}

        template <typename TupleT>
        typename actor_result<ActorT, TupleT>::type
        operator()(TupleT const& args) const
        {
            return actor.eval(args);
        }

        ActorT actor;
    };

    template <typename SigT>
    struct placeholder
    : placeholder_eval<placeholder<SigT>, SigT>
    {
        template <typename RHS>
        placeholder(RHS const& rhs)
        : f(placeholder_ftor<RHS>(rhs)) {}

        placeholder(placeholder const& rhs)
        : f(rhs.f) {}

        template <typename RHS>
        placeholder&
        operator=(RHS const& rhs)
        { f = placeholder_ftor<RHS>(rhs); }

        placeholder&
        operator=(placeholder const& rhs)
        { f = rhs.f; }

        typedef actor<placeholder<SigT> > type;
        typename placeholder_types<SigT>::function_type f;
    };

} // namespace phoenix




#include <iostream>
using namespace std;
using namespace phoenix;

int
main()
{
    placeholder<int(int)>::type         inc = arg1 + 1;
    placeholder<int(int)>::type         sqr = arg1 * arg1;
    placeholder<int(int, int)>::type    add = arg1 + arg2;

    int     i = 3;
    int     j = 4;

    cout << inc(i) << endl;                 // result = 4
    cout << (inc + inc + sqr)(i) << endl;   // result = 17
    cout << (inc + add)(i, j) << endl;      // result = 11

    return 0;
}