#include <boost/proto/proto.hpp>
namespace proto = boost::proto;
namespace mpl = boost::mpl;

struct frac {};

struct simplifyfct
{
  typedef frac result_type;
  frac const & operator()(frac const & f) const { return f;}
};

template <typename Expr>
struct frac_calculator;

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

template <typename EXPR>
struct simexpr 
{
  BOOST_PROTO_BASIC_EXTENDS(EXPR, simexpr, frac_domain)
  BOOST_PROTO_EXTENDS_FUNCTION()
};

simexpr<proto::terminal<simplifyfct>::type> const  sim = {{}};

struct frac_context : proto::callable_context<frac_context> {};

template<typename Expr>
struct frac_calculator
  : proto::extends<Expr, frac_calculator<Expr>, frac_domain>
{
  typedef proto::extends<Expr, frac_calculator<Expr>, frac_domain> base_type;

  frac_calculator(Expr const &expr = Expr())
    : base_type(expr)
  {}
};

/* The following grammar works */
struct RemoveAllSim
  : proto::or_<
  proto::when<
    proto::function<proto::terminal<simplifyfct>, RemoveAllSim>
    , RemoveAllSim(proto::_right)
    >
  , proto::terminal<frac>
  >
{};

/* The following grammar does not work */
struct RemoveSim
  : proto::or_<
  proto::when<
    proto::function<proto::terminal<simplifyfct>, proto::function<proto::terminal<simplifyfct>, proto::_> >
    , RemoveSim(proto::_right)
    >
  , proto::function<proto::terminal<simplifyfct>, proto::_>
  , proto::terminal<proto::_>
  >
{};

int main () {
  frac a, b;
  frac_context C;

#define TESTEXPR (sim(sim(sim(sim(a)))))

  frac c = proto::eval(TESTEXPR, C);                // THIS WORKS!
  c = proto::eval( RemoveAllSim()( TESTEXPR ) , C); // THIS WORKS!
  c = proto::eval( RemoveSim()( TESTEXPR ) , C);    // THIS DOES NOT WORK!

  return 0;
}