#include <string>
#include <iostream>
#include <boost/proto/proto.hpp>
#include <boost/utility/enable_if.hpp>

namespace mpl = boost::mpl;
namespace proto = boost::proto;

namespace detail
{
    // Define has_which trait
    BOOST_MPL_HAS_XXX_TRAIT_DEF(which)

    template<typename Expr, typename Grammar, typename EnableIf = void>
    struct get_which
    {
        typedef Grammar type;
    };

    // Only proto::or_, proto::switch_ and proto::if_ have branches and
    // need to define a which member.
    template<typename Expr, typename Grammar>
    struct get_which<
        typename Expr
      , typename Grammar
      , typename boost::enable_if_c<has_which<proto::matches<Expr, Grammar> >::value>::type
    >
    {
        typedef typename proto::matches<Expr, Grammar>::which type;
    };
}

template<typename Grammar, typename Actions>
struct algorithm
  : proto::transform<algorithm<Grammar, Actions> >
{
    typedef Grammar proto_grammar;

    // Cheating! relies on Proto implementation details (the
    // presence of a nested which typedef in proto::matches).
    template <typename Expr, typename State, typename Data>
    struct impl
      : Actions::template
            when<typename detail::get_which<Expr, Grammar>::type, Actions>::template
                impl<Expr, State, Data>
    {};
};

namespace boost { namespace proto
{
    template <typename Grammar, typename Actions>
    struct is_callable<algorithm<Grammar, Actions> >
      : mpl::true_
    {};
}}

struct int_terminal
  : proto::terminal<int>
{};

struct char_terminal
  : proto::terminal<char>
{};

struct plus_int_int
  : proto::plus<int_terminal, int_terminal>
{};

struct my_grammar
  : proto::or_<
        int_terminal
      , char_terminal
      , plus_int_int
    >
{};

struct my_actions;

struct print : proto::callable
{
    typedef std::string result_type;

    result_type operator()(int) const
    {
        return "int";
    }

    result_type operator()(char) const
    {
        return "char";
    }

    template <typename T1, typename T2>
    result_type operator()(T1 res, T2 t2) const
    {
        res += " + ";
        res += t2;
        return res;
    }
};

struct my_actions
{
    template <typename Grammar, typename Actions = my_actions>
    struct when;

    template <typename Actions>
    struct when<int_terminal, Actions>
      : proto::call<print(proto::_value)>
    {};
    
    template <typename Actions>
    struct when<char_terminal, Actions>
      : proto::call<print(proto::_value)>
    {};
    
    template <typename Actions>
    struct when<plus_int_int, Actions>
      : proto::call<
            print(
                proto::call<algorithm<my_grammar, Actions>(proto::_left)>
              , proto::call<algorithm<my_grammar, Actions>(proto::_right)>
            )
        >
    {};
};

int main()
{
    proto::literal<int> i(8), j(9);
    proto::literal<char> a('a'), b('b');

    std::cout << algorithm<char_terminal, my_actions>()(a)  << "\n"; // printing char
    proto::assert_matches_not<algorithm<int_terminal, my_actions> >(a);
    //std::cout << algorithm<int_terminal, my_actions>()(a)   << "\n"; // precondition violation
    proto::assert_matches_not<algorithm<char_terminal, my_actions> >(i);
    //std::cout << algorithm<char_terminal, my_actions>()(i)  << "\n"; // precondition violation
    std::cout << algorithm<int_terminal, my_actions>()(j)   << "\n"; // printing int
    std::cout << algorithm<my_grammar, my_actions>()(j)     << "\n"; // printing int
    std::cout << algorithm<my_grammar, my_actions>()(a)     << "\n"; // printing char
    std::cout << algorithm<my_grammar, my_actions>()(i + i) << "\n"; // printing int + int
}