#include <boost/proto/proto.hpp>
#include <string>
#include <iostream>
#include <boost/mpl/char.hpp>

namespace boost { namespace proto
{
    struct external;

    // This specialization uses the Data parameter as a collection
    // of actions that can be indexed by the specified rule.
    template<typename Grammar>
    struct when<Grammar, external>
    {
        typedef typename Grammar::proto_grammar proto_grammar;

        template<typename Expr, typename State, typename Data>
        struct impl
          : Data::template when<Grammar>::template impl<Expr, State, Data>
        {};

        template<typename Expr, typename State, typename Data>
        struct impl<Expr, State, Data &>
          : Data::template when<Grammar>::template impl<Expr, State, Data &>
        {};
    };
}}

namespace mpl = boost::mpl;
namespace proto = boost::proto;
using proto::_;

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

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

struct my_grammar
  : proto::or_<
        proto::when< int_terminal, proto::external >
      , proto::when< char_terminal, proto::external >
      , proto::when<
            proto::plus< my_grammar, my_grammar >
          , proto::fold< _, int(), my_grammar >
        >
    >
{};

struct print : proto::callable
{
    typedef std::ostream & result_type;

    template<typename T>
    result_type operator()(T t) const
    {
        return std::cout << t << ", ";
    }
};

struct my_actions
{
    template <typename Grammar>
    struct when;
};

template<>
struct my_actions::when<int_terminal>
  : proto::call<print(proto::_value)>
{};

template<>
struct my_actions::when<char_terminal>
  : proto::call<print(char(boost::mpl::char_<'x'>()))>
{};

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

    my_actions act;
    my_grammar()(a + i, 0, act);
    std::cout.put('\n');
}