Re: [boost] [Proto] Copying expressions

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

Eric Niebler <eric_at_[hidden]> writes:

> Maurizio Vitale wrote:
<snip>
>> 
>> 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)<
                    BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_TYPE, ~)
                > > 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 = {
                        BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~)
                    };
                    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);

and:

  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,

       Maurizio