On Sun, Nov 29, 2009 at 10:27 AM, CR Koudella
Thanks for your reply on this, too. Yes, I am beginning to look into phoenix. Here too, it would be of great help if you could indicate to me how you would handle my example with phoenix.
Since you have code in this one I should be able to come up with a
phoenix example:
// Assume this line everywhere:
using namespace boost::phoenix;
// For doing h*(f-g)^2 generically in phoenix:
auto func1 = _3*(_1-_2)*(_1-_2);
// Or more 'optimized' as this (which the compiler may optimize the
above just fine as well, but this demonstrates local vars):
auto func1 = let(_a=(_1-_2))[_3*_a*_a];
// Results in this:
func1(3,2,1) -> 1
func1(6,4,2) -> 8
... etc
That barely demonstrates the surface of phoenix. Phoenix practically
rewrites C++ in C++ in a lazy form, very powerful, but that should
give you an example. As for your nasty binds in binds in binds in
etc... Maybe this?
// Supposing f, g, and h are static functions and there is only one
variable passed in (phoenix cares not what type it is, as long as
f/g/h can resolve it), you were not really clear on exactly what your
code is supposed to do.
auto bfoWRF = let(_a=(bind(&f, _1)-bind(&g, _1)))[bind(&h, _1)*_a*_a]
// In which case if you have this:
std::vector v = {...}
// and you call this:
auto value = bfoWRF(v);
// then it does the same thing as this non-lazy code:
auto a = f(v)-g(v);
auto value = h(v)*a*a;
And yes, you can combine different returns just fine as long as they
obey the normal non-lazy C++ rules.
P.S. If you want to assign bfoWRF to a boost function, it will be as
you may think:
boost::function