Boost logo

Boost :

Subject: Re: [boost] Rave for proposed Boost.Local (functions)
From: Thomas Heller (thom.heller_at_[hidden])
Date: 2011-02-02 07:21:57

Phil Endecott wrote:

> Thomas Heller wrote:
>> I would be interested in what limitations you ran into using Boost.Lambda
>> and if you are aware of the recent efforts that were put into
>> Boost.Phoenix?
>>> To my mind this example looks a lot clearer if you reformat it as
>>> follows:
>>> (void) (add)(
>>> (double)(num)
>>> (const bind)((factor))
>>> (bind)((&sum))
>>> )
>>> ) {
>>> sum += factor * num;
>>> std::clog<< "Summed: "<< sum<< std::endl;
>>> add(100.0);
>> As far is a am concerned, I still find this syntax overly verbose.
>> I do realize though that this is just a toy example. For better
>> comparison, Here is how the same thing would like in Boost.Phoenix:
>> boost::function<void(double)> add
>> =(
>> ref(sum) += factor * _1,
>> std::clog << var("Summed: ") << sum << std::endl
>> )
>> ;
>> add(100.0);
>> but how are the above examples (both of
>> Boost.Local and Boost.Phoenix) not C++ syntax?
> Well, to spell out the obvious, the way that the Boost.Local code
> terminates statements with ';' while the Pheonix code uses ',' is a
> reasonably good example of "normal" vs. "obfuscated" syntax. Then
> there is all the replacement of keywords, changing of brackets,
> numbered vs. named parameters, and extra bits of fluff like ref() and
> bind(). No doubt it seems like second-nature once you are used to it,
> but I'd much prefer to use "normal" C++ syntax to write lambdas if I can.

Point taken.
OTOH the macros used to define the local functions are not even close to
those of either C++0x lambdas or regular C++ functions.
The "fluff" and "obfuscated" syntax you find in Phoenix et al in the body of
the expressions, was shifted in Boost.Local to the function decelerator.

> Again, since the future is no doubt C++0x lambdas, should we be trying
> to converge towards that? I.e. choosing whatever approach has the
> closest syntax to that?

1) It is, IMHO, not only a matter of the syntax used in the body of the
statements (regular C++ with Boost.Local vs. stylized, emulated C++ in
Boost.Phoenix). It is how the general usecase is, which is probably a
inplace definition of some unnamed function, to be used in some std
algorithm, as callback in for example boost.asio etc. Boost.Local
unfortunately can not deliver that inplace definition:
std::for_each(v.begin(), v.end(), ...);

C++0x lambdas, Boost.Bind, Boost.Lambda and Boost.Phoenix:
std::for_each(v.begin(), v.end(), some_lambda_expression);

2) Even though C++0x will support unnamed functions as a language feature,
Boost.Phoenix will not become obsolete. Quite the opposite, Boost.Phoenix
offers a lot of advantages over C++0x lambdas. (Forgive me if I won't go
into detail here about that, this thread is about Boost.Local)
Whereas Boost.Local are just a complicated way to express what can be done
with C++0x lambdas, I see no real advantage of Boost.Local over C++0x


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