#include <boost/proto/proto.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/type_traits/is_same.hpp>

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

template<class Expr, class Dummy = proto::is_proto_expr>
struct my_expr;

struct generator
  : proto::transform<generator>
{
  template<class Expr, class State, class Data>
  struct impl : proto::transform_impl<Expr, State, Data>
  {
    typedef typename impl::expr expr;
    typedef typename proto::tag_of<expr>::type tag;
    typedef my_expr<expr> type;
    
#if 1
    typedef boost::proto::tag::plus tag_for_which_is_expr_should_be_avoided;
#else
    typedef boost::proto::tag::function tag_for_which_is_expr_should_be_avoided;
#endif
    
    typedef typename mpl::
    if_< mpl::
         and_< mpl::
               not_< boost::is_same<tag, tag_for_which_is_expr_should_be_avoided> >
             , proto::is_expr<type>
             >
       , type
       , type
       >::type                  result_type;
    
    result_type operator()( typename impl::expr_param e
                          , typename impl::state_param
                          , typename impl::data_param
                          ) const
    {
      return result_type(e);
    }
  };
};

struct domain
  : proto::domain<generator>
{
};

template<class Expr, class Dummy>
struct my_expr
#if 1
  : proto::extends<Expr, my_expr<Expr>, domain>
{
    typedef proto::extends<Expr, my_expr<Expr>, domain> parent;
    my_expr(Expr const& expr = Expr()) : parent(expr)
#else
{
    BOOST_PROTO_BASIC_EXTENDS(Expr, my_expr<Expr>, domain);
    my_expr(Expr const& expr = Expr()) : proto_expr_(expr)
#endif
    {
    }
};

template<class T, class Dummy = proto::is_proto_expr>
struct my_terminal
  : my_expr< typename proto::terminal<T>::type >
{
};

int main()
{
  my_terminal<int> i, j;
  i + j;
}