#include<boost/proto/proto.hpp>

using namespace boost;

typedef proto::terminal<int>::type const terminal;

struct equation;

struct addition:
    proto::or_
    <
       proto::terminal<proto::_>,
       proto::plus<addition, addition>
    >
{};

struct equation:
    proto::or_
    <
        proto::equal_to<addition, addition>
    >
{};

template<class Expr>
struct extension;

struct my_domain:
    proto::domain
    <
         proto::pod_generator<extension>,
         equation,
         proto::default_domain
    >
{};

template<class Expr>
struct lhs_extension;

struct my_lhs_domain:
    proto::domain
    <
        proto::pod_generator<lhs_extension>,
        addition,
        my_domain
    >
{};

template<class Expr>
struct rhs_extension;

struct my_rhs_domain:
    proto::domain
    <
        proto::pod_generator<rhs_extension>,
        addition,
        my_domain
    >
{};


template<class Expr>
struct extension
{
     BOOST_PROTO_BASIC_EXTENDS(
         Expr
       , extension<Expr>
       , my_domain
     )

    void test() const
    {}
};

template<class Expr>
struct lhs_extension
{
     BOOST_PROTO_BASIC_EXTENDS(
         Expr
       , lhs_extension<Expr>
       , my_lhs_domain
     )
};

template<class Expr>
struct rhs_extension
{
     BOOST_PROTO_BASIC_EXTENDS(
         Expr
       , rhs_extension<Expr>
       , my_rhs_domain
     )
};

template <typename Grammar, typename Expr>
void matches(Expr const& expr)
{
     std::cout << std::boolalpha
         << proto::matches<Expr, Grammar>::value << "\n";
}


int main()
{
     lhs_extension<terminal> const i = {};
     rhs_extension<terminal> const j = {};


     matches<equation>(i);              // false
     matches<equation>(j);              // false
     matches<equation>(i + i);          // false
     matches<equation>(j + j);          // false
     //matches<equation>(i + j);          // compile error
     //matches<equation>(j + i);          // compile error
     matches<equation>(i == j);         // true
     matches<equation>(i == j + j);     // true
     matches<equation>(i + i == j);     // true
     matches<equation>(i + i == j + j); // true
}