Boost logo

Boost :

Subject: Re: [boost] phoenix::bind
From: Corrado Zoccolo (czoccolo_at_[hidden])
Date: 2008-10-02 10:14:55

On Thu, Oct 2, 2008 at 3:41 PM, Joel de Guzman <joel_at_[hidden]>wrote:

> Giovanni Piero Deretta wrote:
> As I said elsewere, the extra round is hidden when lambda is used to
>> protect a nested expression, but it shows when used a top level:
>> lambda[ for_each(arg1, lambda(_a = arg2)[push_back(arg1, _a)])] () (r, i);
>> There is really really no need for the extra '()' there. There are no
>> local variables in the outer lambda and even if there were, the user
>> can initialize them with lambda(/* init here*/)[...]
> Ok, this I agree.

I think this could complicate the understanding.
It seems Giovanni's complaint is because he sees lambda[] as an introducer
for a lambda expression, but this is in contradiction with the fact that
expressions within the lambda itself could be eagerly evaluated if not
properly wrapped (and introduction of optional lazy functions could even
worse the problem).

I fear an user could think that
 lambda[ std::cout<<"Hello world" ] is actually constructing a delayed
invocation (as in C++0x), while it is not, and it cannot be.

On the other hand, if lambda[] is reserved as intended by Giovanni, what
would be the syntax for creating a lazy function that returns a lazy
function that returns a lazy function? We could handle differently the
topmost lambda and the inner ones, but guessing the number of lambdas
necessary to achieve what you want might be difficult.

For the other requests, e.g. having lazy functions that capture by
reference or const reference, I think a cast like syntax could be handy:

In this way, the way the arguments are captured can be changed not only at
definition site, but also at call site.


dott. Corrado Zoccolo mailto:czoccolo_at_[hidden]
PhD - Department of Computer Science - University of Pisa, Italy

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