Re: [Boost-users] A question about boost::lambda::if_ behavior

From: Simon Buchan (simon_at_[hidden])
Date: 2005-09-22 05:37:28

tom gee wrote:
> Hello Bjorn,
> 
> Thanks for such a quick help. I works now.
> 
> Can you please further explain the usage of var and constant .
> in the expression
> if_(_1 < 24.000001 && _1 > 23.999999)[ cout <<"Bingo:<"<<_1<<">"])
> I understand "Bingo:<" is evaluated immediately, why not ">", which is not a
> lambda expression either, is not
> evaluated along.
> 
Refresher course: an expression like:
cout << foo << bar << endl;
is read (aka parsed) by the compiler to be shorthand for the following:
(((cout << foo) << bar) << endl);
which, incidently is just shorthand for:
operator<<(operator<<(operator<<(cout, foo), bar), endl);
Thus, '<<' is known as a 'left assosiative' (I think :D) operator.
Refresher over.
Basicly, the 'cout << "Bingo:<"' sub-expression has no 'lambda stuff' in 
it, and therefore calls the _normal_ operator<<, which immediately 
prints "Bingo:<". This operator<< returns a reference to cout, so the 
next '<<' sees:
cout << _1
Which (obviously) is an expression containing a lambda (sub-)expression. 
The guys who made this library were nice enough to provide overloads of 
'<<' (along with every other possible operator) that return a 'lambda 
function object', you just have to know that it is a valid lambda 
expression that _will_ evalute as "cout << _the_first_argument_" when 
called. The same happens with the next <<, it sees:
_lambda_operator_left_shift_ << ">"
, where the left argument is the previous lambda function object made 
from the "cout << _1" sub-expression. Now there is _another_ overload of 
<< that creates _another_ lambda function object, that _will_ evalute as 
if it was:
cout << _the_first_argument_ << ">"
So, basicly, anytime there is a sub-expression that doesn't have a 
lambda object in it, it is treated as a normal expression, but if it 
does, it creates a function object that will do what it looks like it 
would do. What 'constant' and 'var' do is make a (lambda?) function 
object that just returns it's argument, as, respectively, a constant 
copy, or a reference to the original (I think, again, use boost::ref to 
be sure)
> Forgive me if this question seems stupid, but I am new to Lambda, fascinated
> by its power, but convoluted by its mechanism yet.
> 
> Thanks.
> 
[snip]

Don't worry about it, but don't forget to read the documentation!
One more thing to keep in mind, the overload for '()', the call 
operator, for a lambda function object immeadiatly evaluates it's 
contained expression, ie:
(_1 + 3)(4) == (4 + 3);
to get around this if you want to delay a call to that object, use:
boost::lambda::bind(_1 + 3, 4);
which returns a lambda function object that when called, calls the first 
argument with the rest of bind's arguments as it's arguments, so:
bind(_1 + 3, 4)() == (_1 + 3)(4) == (4 + 3)
Which is VERY usefull if you want to, say call functions in a STL container:

int i, j;
std::vector<void(*)(int, int)> some_funcs;
...
std::for_each(some_funcs.begin(), some_funcs.end(), bind(*_1, i, j));

Although, Boost.Signals is probably a better bet if you do stuff like 
that a bit.