Re: [boost] phoenix::bind

Subject: Re: [boost] phoenix::bind
From: Peter Dimov (pdimov_at_[hidden])
Date: 2008-10-02 14:58:07

>     for_each(arg1,
>         lambda(_a = arg2)
>         [
>             push_back(arg1, _a)
>         ]
>     )

...

I'm not an expert on modern FP, but the above lambda doesn't seem like a 
classic lambda (as in lambda calculus and Lisp) to me.

Now that I've seen what Phoenix can do, I think that, were I to design a 
Boost.Lambda2, I'd probably go with a classic lambda of the form

    lambda( _x, _y )[ _x + _y ]

where the inner _x + _y is not a function object, and it is the lambda[] 
that turns it into one. (That is, the evaluation of an inner expression 
would be done with eval(expr, args...) and not with expr(args...).)

Local state would look like

    lambda( _x, _a = 0 )[ _a += _x ]

and one can also extend this to lambda( byval, ... ) and lambda( byref, 
... ) to control the default capture behavior. I'd spell function 
application inside a lambda as apply( f, x ) and not as bind, leaving the 
latter as an alias for lambda[ apply ].

So \f \x f (f x) would be

    lambda( _f )[ lambda( _x ) [ apply( _f, apply( _f, _x ) ) ] ]

Using the above example as a test for this theory:

>     for_each(arg1,
>         lambda(_a = arg2)
>         [
>             push_back(arg1, _a)
>         ]
>     )

In lambda terms, it's something like

    \x,y for_each( x, \z push_back( z, y ) )

so (with lazy for_each and push_back):

    lambda( _x, _y )[ for_each( _x, lambda( _z )[ push_back( _z, _y ) ] ) ]

This implies that a lambda[] must be able to access an outer scope. I wonder 
how could one do that. :-) The outer lambda should be able to do some term 
rewriting, I guess.

I should also be able to spell that as:

    lambda( _x, _y )[ for_each( _x, lambda( _x )[ push_back( _x, _y ) ] ) ]

with the two _x being properly scoped.