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"
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