Hi, thank you very much for your help. What you suggest works fine, thanks. I have 'studied' the boost lambda library a bit and get the feeling as it says in the intro to the doc that it is especially meant to write small lambda expressions for use with the STL. I am not actually that interested in this use and am having a bit of time trying to get it to do some other things. Imagine I want to do the following operation [h * (f - g)^2](x), where the x is 'const std::vector<double> &', all functions return double and h(x) = k1 and g(x) = k2, where k1, k2 = const. f is some non-trivial function. I can make this work according to the method you indicate. I am not entirely sure what the optimal is to build the lambda expressions for the constant functions h and g, see below. It seems that I need to drive this step through boost::function, otherwise the code won't compile. // some function f given... // constant h functor const double dh = 4.0; bll::constant_type<double>::type lh(bll::constant(dh)); boost::function<double (const std::vector<double> & vecArg)> bfoh; bfoh = lh; // constant g functor const double dg = 0.5; bll::constant_type<double>::type lg(bll::constant(dg)); boost::function<double (const std::vector<double> & vecArg)> bfog; bfog = lg; // construct h * (f - g)^2 // f - g boost::function<double (const std::vector<double> & vecArg)> bfoDF; bfoDF = bll::bind(f, bll::_1) - bll::bind(bfog, bll::_1); // (f - g)^2 boost::function<double (const std::vector<double> & vecArg)> bfoSF; bfoSF = bll::bind(bfoDF, bll::_1) * bll::bind(bfoDF, bll::_1); // h * (f -g)^2 boost::function<double (const std::vector<double> & vecArg)> bfoWRF; bfoWRF = bll::bind(bfoh, bll::_1) * bll::bind(bfoSF, bll::_1); Other than this, the repetitive use of bll::bind at every stage and generally speaking, the wordiness of the script makes me wonder whether this is the right thing to use or if I am using it as I should. I mean h*(f-g)^2 is a pretty simple operation. Any comments on how to improve the above? In particular on how to build the constant functors h and g? Another question I have is, would it be possible to combine functors with different return types in the same way? Imagine j(x) is now a function that takes in an std::vector<double> and returns an std::vector<double>. Then can it be scaled with a function that takes in an std::vector<double>, but returns a double? BTW, a propos extracting the underlying functor out of a boost::function, yes it isn't ideal, but you might just need to acess the underlying interface at some point. Thanks, ChrisK