How to curry using standard functors - c++

Question

I have the following loop:
MyList li;
vector<Token*>::iterator itr = tokens.begin();
for (; itr != tokens.end(); ++itr) {
li.add_string((*itr)->get_name());
}
I am thinking if I can use functor to replace this loop. One goal here is I could just use standard functor; I do not want to write a separate class just for the purpose of operator().
Here is my version:
for_each(tokens.begin(), tokens.end(),
std::bind1st(std::bind2nd(std::mem_fun(&MyList::add_string),
std::mem_fun(&Token::get_name)),
&li)
);
Unfortunately I get that nasty GCC template compile error.
Can you point me what should be the right functor currying here?
I cannot use c++11.
[EDIT]
My compiler does not support lamda.
Here is the error message if it helps:
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h: In instantiation of 'std::binder1st<std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> > >':
abc.c:823: instantiated from here
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:100: error: no type named 'second_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:103: error: no type named 'first_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:106: error: no type named 'first_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:111: error: no type named 'second_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:117: error: no type named 'second_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h: In function 'std::binder1st<_Operation> std::bind1st(const _Operation&, const _Tp&) [with _Operation = std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >, _Tp = MyList*]':
abc.c:823: instantiated from here
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/backward/binders.h:126: error: no type named 'first_argument_type' in 'class std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> >'
In file included from /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/algorithm:62,
from abc.c:4:
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h: In function '_Funct std::for_each(_IIter, _IIter, _Funct) [with _IIter = __gnu_cxx::__normal_iterator<Token**, std::vector<Token*, std::allocator<Token*> > >, _Funct = std::binder1st<std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> > >]':
abc.c:824: instantiated from here
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/stl_algo.h:4200: error: no match for call to '(std::binder1st<std::binder2nd<std::mem_fun1_t<void, MyList, const std::string&> > >) (Token*&)'
[EDIT2] I know why I get the error now. bind2nd's implementation is this:
template<typename _Operation, typename _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
_Operation is mem_fun_t from MyList::add_string, this is fine because mem_fun_t provides operator() API.
The problem is here: _Arg2_type(__x), because _Arg2_type is _Operation::second_argument_type but mem_fun_t does not have second_argument_type attribute because it is sub-class of unary_function.
Well, if someone could confirming my tracing of type conversion, I'd appreciate it very much.
Thanks Eric, your mentioning "bind1st and bind2d requires the value to be constant" triggers me(but I think your wording is not right per-Se because the key is not the value must be constant, rather the value must be of certain type).
Lastly, GCC extension compose is best solution; I am sure boost has equivalent.

Answer 1

The error comes from the fact you are trying to bind a function as the second parameter for the add_string method of MyList. bind1st and bind2nd requires the value to be constant and are not geared to receive functions as value to bind.
for_each requires a function which takes iterator as first its parameter. What you want to accomplish can't be done without an external function(which is the equivalent of a lambda but not nearly as elegant) if you really insist on using for_each. This function would need to receive the list and token iterator as parameter. You can then bind the list to the function with either bind1st or bind2nd depending on the order in which you declare the parameter.
Let's you have this function:
void AddTokenNameToList(MyList& li, Token* token)
{
li.add_string(token->get_name());
}
You could have this for_each:
for_each(tokens.begin(), tokens.end(), std::bind1st(AddTokenNameToList, li));
If list parameter were inverted, you would use bind2nd instead to bind the list value.
You could argue that this function is custom for this particular case and not as elegant as using only std methods. I guess you could get crazy and template that function to receive method to apply to first parameter and the one for the second but what you really want here is a lambda and since you can't use them, this is as close as you gonna get.
At this point however, you have to wonder if it really saves code. That's one of the reason bind1st and bind2nd have bad rep and considered almost useless. However it lets you use some other nice algorithm so they still have some advantages.

Answer 2

If your compiler supports it, you can use lambdas:
for_each(tokens.begin(), tokens.end(), [&li] (Token * val)
{
li.add_string(val->get_name());
} );