On 11/05/2010 1:45 PM, alfC wrote:

...

...

The question is: What should be the type of XXXX and YYYY?

You'll have to make operator() a template:

template<class T> function operator()(const T& x_arg, double y_arg);

I was about to do that but then I though that doing so would open a can of uncontrolled overload. What if I want to restrict T to lambda expressions? what would be the best way to do it, enable_if? some special tag? (Do lambda expression have any special tag?)

Thank you, Alfredo

What about forcing T to be or be derived from an expression template base class?

On 11/05/2010 7:47 PM, alfC wrote:

...

...

You'll have to make operator() a template:

...

...

template<class T> function operator()(const T& x_arg, double y_arg);

...

...

What if I want to restrict T to lambda expressions?

What about forcing T to be or be derived from an expression template base class?

How can I do that? Can you point me to the right documentation if any.

In the context of Boost.Lambda there is no common base class for all expression templates (is there?), for example the placeholders do not inherit from anything. The only thing I found was the subclass 'sig' that seems to be defined for all expression types. But I am still scratching my head on how to expoit this 'sig' subclass.

Now that I think one obvious way to restrict T is to be an expression template that 'returns' a double (or convertible to 'double'), this information is contained in the sig subclass. But I am confused now to do any progress.

Alfredo

http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Expression-template http://www.boost.org/libs/numeric/ublas/doc/expression_concept.htm C++ Expression Templates By Angelika Langer and Klaus Kreft, March 01, 2003 http://www.drdobbs.com/184401627 I have yet to tinker with expression templates in any meaningful way (aside from copy/pasting the example from wikibooks.org and playing with it), so beyond giving you those links as guides there's not much I can do. I do know that it's exactly what you want though and that the keys to your kingdom are the Var and Constant classes (or equivalent) from the wikibooks.org article. Good luck! Geoff

On May 11, 7:10 am, Steven Watanabe wrote:

...

since I have access to f I would like to make fsmartenough to handle its own binding. Eg. You'll have to make operator() a template: template<class T> function operator()(const T& x_arg, double y_arg);

Thank you Steven for pointing that out. This is simplest still useful solution I found. I realized that returning function would defeat the purpose since it is not a lambda expression an I would need bind again to insert it in a lambda expression this is the soltution class A{ typedef A this_type; double operator()(double const& x) const{return evaluate(x);} //this is the function that performs the actual work //the following creates a lambda expression using operator() template<class LambdaExp> lambda_functor >, tuple< double (this_type::* const)(const double&)const, const this_type, //this class lambda_functor<LambdaExp> const > > > operator()(lambda_functor<LambdaExp> const& exp) const{ return bind( static_cast(&this_type::operator()), static_cast(*this), //static_cast not necesary but maybe usefull if CRTP worked exp ); } } it can be used as A a; a(5.); //evaluates at 5. a( _1 + _1) or any lambda expression); //gives a bind lambda expression. as you see the most complicated part is the return type of the function. It can be generalized to functions that take two arguments, if mixed symbolic/numeric evaluation is needed other combinations of can be made or simply using lambda::constant for one or two of the arguments. I tried to use CRTP (e.g. class A: public self_binder<A>{...}) to define the new member in a more generic way but I couldn't because the template member function in a base (parent) class can not be resolved by calling A::operator()(lambda_expr). Maybe as OvermindDL1 said Boost.Phoenix can do better in terms of shorted syntax or by allowing CRTP in some way. Unfortunately I don't know enough Phoenix, maybe Phoenix has a "function" class that is a phoenix-lambda by itself. Thank you, Alfredo

On May 27, 12:25 am, alfC wrote:

This is simplest still useful solution I found. I realized that returning function would defeat the purpose since it is not a lambda expression an I would need bind again to insert it in a lambda expression

this is the soltution (see code in previous post)

this is the generalization to function objects that take *two* arguments, note that there are two template parameters now. As you see the code is still quite long, I didn't find a way to simplify it. (I still didn't manage to use CRTP for example.) class A{ typedef A self_type; ... complex operator()(quantityatomic::wavenumber const& k, quantityatomic::frequency const& w) const{ //function that does the real work ... } template lambda_functor >, tuple< //signature of function that does the real work complex(self_type::* const)(quantityatomic::wavenumber const&, quantityatomic::frequency const&) const, const self_type, lambda_functor<LambdaExp1> const, lambda_functor<LambdaExp2> const > > > operator()(lambda_functor<LambdaExp1> const& exp1, lambda_functor<LambdaExp2> const& exp2) const{ return bind( //signature is repeated here static_castatomic::wavenumber const&, quantityatomic::frequency const&) const>(&self_type::operator()), static_cast(*this), //static_cast not necesary until we manage to put this in CRTP base class exp1, exp2); } };