>The upcoming version of Boost, 1.34, will contain the Boost.Typeof library
>that will provide the BOOST_TYPEOF and BOOST_AUTO macros to emulate this
>facilities.  The current snapshot of 1.34 can be obtained from Boost CVS.
Thanks for the info! Look forward to look at this.

The following works on g++ 4.0.2:
typedef typeof(lambda::_1 + lambda::_2) T1;
T1 f = lambda::_1 + lambda::_2;
typedef typeof(f*lambda::_1) T2;
T2 g = f*lambda::_1;

Let's say I have to parse "(_1 + _2)*_1" and "(_1/_2)*_1". I only get these command strings at runtime so I don't know the expressions at compile time.
I have to parse the strings and gradually build the lambda expression. First the expression within parenthesis has to be created and then the result combined with *_1
to create the final expression. The type of the first expression is not the same in  the 2 cases so how do I store/refer to the first expression?
All possible templates must be evaluated at compile ime so I somehow must limit the possibilities at compile time. Furthermore how can I select a type based on a runtime parameter?
I must admit I have overstretched myself here so I am not sure if I'm overlooking something or if this is impossible.
I had thought about expression templates but I wouldn't want to duplicate what the lambda library is already doing. Anyway it seems to me I would have the same problem as above about
type deduction from a runtime parameter.
All helpful remarks greatly appreciated.

cheers
Arnaldur



"Arkadiy Vertleyb" <vertleyb@hotmail.com>
Sent by: boost-users-bounces@lists.boost.org

18.10.2006 19:36
Please respond to
boost-users@lists.boost.org
To
boost-users@lists.boost.org
cc
Subject
Re: [Boost-users] creating lambda expressions incrementally





"Arnaldur Gylfason" <arnaldur.gylfason@decode.is> wrote

>I´m writing a simple expression parser in boost::spirit that can parse a
>string like "_1 + _2" or "log(_1)" and return a function object that does
>just that.
>I used boost::lamda for that and return it as boost::function object.
>Now I want to parse compositions like "sqrt(_1*_1 + _2*_2)" or "(_1 +
>_2)*_2" etc. It is easy to parse this of course but I have to create the
>corresponding function incrementally (in a loop or recursively)
>and that means I have to keep incremental lambdas until the whole
>expression has been created.
>I can not store them as boost::function since they do not work with lambda
>operator overloading (apart from the fact that it would be too costly).
>I need a lambda type for these intermediate lambda objects. I guess the
>auto type specifier would solve this but when will that be available I
>wonder?

The upcoming version of Boost, 1.34, will contain the Boost.Typeof library
that will provide the BOOST_TYPEOF and BOOST_AUTO macros to emulate this
facilities.  The current snapshot of 1.34 can be obtained from Boost CVS.

>The typeof seems to provide a solution though. I was just trying it and it
>seems to work!

For the Boost.Typeof library to handle lambda expressions, on the platforms
where typeof is not natively supported, Boost.Lambda templates need to be
registered.  The Boost.Typeof documentation describes this using
Boost.Lambda as an example.  Generally it's up to maintainers of Lambda
library to decide if to provide the typeof support, and, to the best of my
knowledge, it won't happen in 1.34 :(

This registration of the lambda templates can be also done externally
(again, see the typeof docs on how to do this), but this has to be kept
in-sync with the Lambda templates.

The two Boost libraries to support typeof in 1.34 will be spirit and
xpressive.

Regards,
Arkadiy



_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users