Boost logo

Boost :

From: Maurizio Vitale (mav_at_[hidden])
Date: 2007-07-17 13:58:22

Eric Niebler <eric_at_[hidden]> writes:

> Maurizio Vitale wrote:
>> My mental model was:
>> - proto::deep_copy traverse the expression top-down replacing references with value.
> Actually, bottom-up, but yes references are replaced with values.

It is probably terminology, but the following seems top-down to me: you're asked to deep-copy
an expression and you assemble an expression which has the same shape (tag and argcount) of the
original and as children the result of recursive evaluations of deep-copy on the children.

    #define N BOOST_PP_ITERATION()

            template<typename Expr>
            struct deep_copy_impl<Expr, N>
                typedef expr<typename Expr::proto_tag, BOOST_PP_CAT(args, N)<
> > expr_type;
                typedef typename Expr::proto_domain::template apply<expr_type>::type type;

                template<typename Expr2>
                static type call(Expr2 const &expr)
                    expr_type that = {
                    return Expr::proto_domain::make(that);

>> - generators are used to wrap expressions as they are built bottom-up
> Generators are used whenever you want to customize the result of proto's
> operator overloads.

Yes, and my reading of the behaviour of the specific generator you wrote is that
everytime you construct an expression you evaluate deep_copy on it.
Modulo the number of evaluations of deep_copy, I still don't see any difference
between using deep_copy on the toplevel expression and using the generator for
building an already deep-copied solution (other than, as you point out later in
one case you have to explicitely call deep_copy while in the other expressions
naturally spring to life without references)

>> So, assuming that the expression is properly wrapped in lambda_expr<> why the result
>> of calling proto::expr on the whole expression would be different from using the generator?
> Sorry, I don't understand the question.

I guess my question is what is the difference between:

  struct lambda_domain : domain<generator<lambda_expression> > {};
  auto expr = deep_copy(_1 + 42);


  auto expr_1 = _1 + 42; in the case where the generator you provided is used

Aren't expr and expr_1 exactly the same?

> How this helps is that as phoenix expressions are being built, the
> phoenix generator will ensure that all the nodes are held by-value.
> There will never be a need for the user to deep_copy phoenix expressions
> explicitly -- it's done piecemeal by phoenix. So function<> is passed an
> object that does not need to be deep-copied.

I see this difference now and understand the reasons behind your suggestion.
Thanks for the explanation,


Boost list run by bdawes at, gregod at, cpdaniel at, john at