...

typename LambdaExp::template resultsi::length  >  >::type

...

it gives:

...

error_cant_deduce_type (instread of the equivalent of quantitysi::area, like in quantitysi::area  a = quantitysi::length()*quantitysi::length() )

Could you please post a minimal cpp file for this one too?

this is a minimal example: #include #include<iostream> #include<typeinfo> #include using namespace boost::phoenix; using namespace boost::phoenix::arg_names; using namespace boost::units; template<class LambdaExp> void expression_analizer(actor<LambdaExp> l){ std::clog <<"type of argument expression: " <

::type ).name()<si::length > >::type ).name()<si::length()*quantitysi::length() ).name() <

int main(){ expression_analizer(arg1*arg1); return 0; } /*************end of example**************************/

AMDG Joel de Guzman wrote:

When you do a*a with quantitysi::length, what is the expected return type?

quantitysi::area

(looks like a phoenix-2 limitation. hopefully, this will all get sorted out with phoenix-3).

In Christ, Steven Watanabe

On 6/4/10 10:31 AM, alfC wrote:

On Jun 3, 7:16 pm, Steven Watanabe wrote:

...

Joel de Guzman wrote:

...

When you do a*a with quantitysi::length, what is the expected return type?

quantitysi::area rigth.

and in case you wonder, Boost.Units has a bunch of template functions to obtain the result type of arithmetic operations. For example boost::units::multiply_typeof_helper::type, these are heavily used in boost/units/lambda.hpp, which makes lambda play well with units.

...

...

(looks like a phoenix-2 limitation. hopefully, this will all get sorted out with phoenix-3).

so, there is no hope with phoenix-2? can't we do something temporary like boost/units/lambda.hpp to help phoenix-2 to deduce the type? is it possible?

There is hope. Just specialize boost::phoenix::result_of_xxx (e.g. boost::phoenix::result_of_plus). See phoenix/operator/arithmetic.hpp for example. Regards, -- Joel de Guzman http://www.boostpro.com http://spirit.sf.net

On 6/5/10 6:01 AM, alfC wrote:

On Jun 3, 7:52 pm, Joel de Guzman wrote:

...

...

On 6/4/10 10:31 AM, alfC wrote: There is hope. Just specialize boost::phoenix::result_of_xxx (e.g. boost::phoenix::result_of_plus). I specilized result_of_multiplies and still no luck:

#include #include<iostream> #include<typeinfo> #include

namespace boost{ namespace phoenix{ using namespace boost::units; template<> //in general template struct result_of_multipliessi::length, quantitysi::length

...

...

{ typedef quantitysi::area type; }; }}

The type-deduction respects references. Phoenix2 passes in references. The code should be: template<> //in general template struct result_of_multipliessi::length&, quantitysi::length&> { typedef quantitysi::area type; }; Regards, -- Joel de Guzman http://www.boostpro.com http://spirit.sf.net

On 6/4/2010 8:55 PM, alfC wrote:

Thank you so much for your help. Boost.Units and Boost.Interval will be good benchmark test for the type deduction of Phoenix3 (what will be the magic of P3? use of typeof?)

Yes. Phoenix 3 will be forward-looking in this regard. Most compilers at least support Boost.Typeof, and many now have decltype. Type deduction will be automatic in most cases; at worst, you may need to register your user-defined types with Boost.Typeof. -- Eric Niebler BoostPro Computing http://www.boostpro.com

On Jun 4, 5:55 pm, alfC wrote: So, I have to implement this kind of macro sorcery to bridge Boost.Units and Boost.Phoenix. Not sure if I will find another bump in the road:

namespace boost{ namespace phoenix{ using namespace boost::units; #define RESULT_OF_GEN( PhoenixnamE, UnitsnamE, RefQ1, RefQ2 ) \        template \        struct result_of_##PhoenixnamE RefQ1, quantity RefQ2>{ \                typedef typename UnitsnamE##_typeof_helper&,quantity&

...

::type type; \        };        RESULT_OF_GEN(multiplies, multiply, &,  )        RESULT_OF_GEN(multiplies, multiply, &, &)        RESULT_OF_GEN(multiplies, multiply,  ,  )        RESULT_OF_GEN(multiplies, multiply,  , &)        RESULT_OF_GEN(divides   , divide  , &,  )        RESULT_OF_GEN(divides   , divide  , &, &)        RESULT_OF_GEN(divides   , divide  ,  ,  )        RESULT_OF_GEN(divides   , divide  ,  , &) #undef RESULT_OF_GEN }}

On top of what is above, I had to add the code below in order to be able to use Phoenix in this context: using namespace boost::units; using namespace boost::phoenix; using namespace boost::phoenix::arg_names; ... boost::functionsi::area(quantitysi::length)> f = arg1 * si::meter; cout << f(4.*si::meter) < > (which may or may not make sense, seems not to). (I used boost::function just to make the example clear). Here is the code to make this work, i.e. use phoenix and units in a expression, (sorry again if I am not supposed to mess with phoenix internals in this way): namespace boost{ namespace phoenix{ #define RESULT_OF_QUANTITY_UNITS_GEN( PhoenixopnamE, UnitsopnamE ) \ template \ struct result_of_##PhoenixopnamE < \ boost::units::quantity &, \ boost::units::unit \

{ \ typedef \ typename boost::units::UnitsopnamE##_typeof_helper< \ boost::units::quantity, boost::units::unit \ >::type type; \ }; RESULT_OF_QUANTITY_UNITS_GEN(multiplies, multiply) RESULT_OF_QUANTITY_UNITS_GEN(divides , divide ) #undef RESULT_OF_QUANTITY_UNITS_GEN

// this refines the operator* so the phoenix:;operator* is used instead of units::operator* #define REFINE_ARITHMETIC_OPERATORS(PhoenixopnamE, CsymboL) \ template< \ class PhoenixExpr, \ class System, \ class Dim \

\ actor< \ composite< \ PhoenixopnamE##_eval, \ boost::fusion::vector< \ PhoenixExpr, \ value< \ boost::units::unit \ > \ > \

...

\ \ operator CsymboL (const actor<PhoenixExpr>& lhs, const unit& rhs){ \ return compose(lhs, rhs); \ } REFINE_ARITHMETIC_OPERATORS(multiplies, *) REFINE_ARITHMETIC_OPERATORS(divides, /) #undef REFINE_ARITHMETIC_OPERATORS }}

On 6/4/10 10:16 AM, Steven Watanabe wrote:

AMDG

Joel de Guzman wrote:

...

When you do a*a with quantitysi::length, what is the expected return type?

quantitysi::area

...

(looks like a phoenix-2 limitation. hopefully, this will all get sorted out with phoenix-3).

Ok, phoenix-2's type deduction can't deduce that alright. Sorry. Best you can do is specialize boost::phoenix::result_of_xxx for your types. Regards, -- Joel de Guzman http://www.boostpro.com http://spirit.sf.net