Re: [Boost-users] [proto] a question on assignment operators

24 Aug 2009

      (Public response to Maurizio's private follow-up. Hope Maurizio doesn't 
mind.)

Maurizio Vitale wrote:
...
...
...
...
...
...
"Eric" == Eric Niebler  writes:
Eric> Maurizio Vitale wrote:
    >> Hi Eric, while you were on vacation I posted the following on the
    >> boost.users
    Eric> <snip>
Eric> Sorry for the delay; I missed your original message. I've
    Eric> followed up on the boost-users list. In short: I don't
    Eric> understand enough of what you're trying to do to help. Please
    Eric> clarify and I'll help as best I can.
Let me try to rephrase what I was trying to ask and see if I'm more
successful.
The gist of the question is what happens when you have to add an
operator= to a proto extended expression. You normally wouldn't because
in general it doesn't make much sense to do things like:
a+b = c-d;
(although it could make sense in a DSL for linear algebra)
In my case something like:
(a,b,c) = expression;
would require to do (inside my_expr::operator=):
a = f (expression);
b = g (expression);
c = h (expression);
where f,g,h depend on the semantics. In my case they would carve a
certain number of bits from expression. In a DSL dealing with tuples
they would select the appropriate component from expression.
OK sure, that makes sense.
...
The problem I'm having is that expressions built by proto seem to be
const, forcing operator= to be const (or at least that's what happens in
my example).
It's true, Proto's objects have a top-level const qualification. They 
are, after all, rvalues (temporaries) so they should not be modified.

HOWEVER, the const-ness only applies at the top-level. The const-ness of 
child nodes is preserved. In particular, non-const lvalue terminals are 
held by reference and remain non-const. Consider:

   typedef proto::terminal<int>::type I;
   I i = {42};
   I & refi = proto::left(i+i);

The temporary object created by i+i is const, but each i is held by 
non-const reference, which is what is returned by proto::left.
...
If that's true, then my followup question was whether it is
ok to perform the assignment the way I was doing it, casting away const.
In short, it shouldn't be necessary. You're using proto::flatten and 
fusion::fold. Somewhere in there the constness is getting messed up. You 
should file a bug.

Proto's fold_tree transform gets the constness correct. See the attached 
code which is equivalent to yours, but doesn't require any ugly 
const_cast's.
...
The other question I had was on what was the reason for explicitely
disable assignment operators in grammars. This is something you do in
many of your examples
I do? Which examples? I don't see it.
...
, but doesn't seem to make a difference in my code
(e.g. having an operator= in my expression seems to stop proto from
building a larger tree including the '=' anyhow, without needing to
disable it explicitly)
I'm afraid you've lost me again.
...
The last question, which was the first, it is not very important. What
I'm really interesting in is how to use proto when you need to assign to
a proto expression, rather than a proto terminal.
And I hope at least that much has been cleared up.

HTH,

-- 
Eric Niebler
BoostPro Computing
http://www.boostpro.com

#include <iostream>
#include 
#include 
#include 
#include 

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

struct my_grammar : proto::or_<
  proto::terminal< int >,
  proto::binary_expr<_, my_grammar, my_grammar>
...
{};

template<typename Expr>
struct my_expr;

struct my_domain : proto::domain, my_grammar>
{};

struct AssignTerminal : proto::callable
{
  template<typename Sig>
  struct result;

  template
  struct result
  {
    typedef mpl::plus type;
  };

  template
  mpl::plus
  operator()(Terminal & t, Offset) const
  {
    proto::value(t) = Offset::value;
    return mpl::plus();
  }
};

struct AssignGroup
  : proto::fold_tree<
      proto::_,
      mpl::size_t<0>(),
      AssignTerminal(proto::_, proto::_state)
    >
{};

template<typename Expr>
struct my_expr
  : proto::extends
{
  typedef proto::extends base_type;

  my_expr( Expr const & expr = Expr() )
    : base_type( expr )
  {}

  template<typename E>
  const my_expr& operator=(const E&) const
  {
    AssignGroup()(*this);
    return *this;
  }
};

struct my_int
  : my_expr< proto::terminal< int >::type >
{
  typedef my_expr< proto::terminal< int >::type > base_type;
  explicit my_int (int i = 0) : base_type (base_type::proto_base_expr::make (i)) {}
  operator int () { return proto::value (*this); }
};

int main()
{
  my_int i (1);
  my_int j (2);
  my_int k (3);

  (k,j) = (j,k);

  std::cout << j << std::endl << k << std::endl;
}

/// Local Variables:
/// mode:c++
/// comment-column:60
/// fill-column:150
/// compile-command:"g++ -I. -I./boost -o testcase testcase.cpp"
/// c-macro-cppflags:"-C -I. -I./boost"
/// c-backslash-column:120
/// c-backslash-max-column:149
/// End: