How to use boost::fusion::transform on heterogeneous containers?

Boost.org's example given for fusion::transform is as follows:

struct triple
{
    typedef int result_type;

    int operator()(int t) const
    {
        return t * 3;
    };
};
// ...
assert(transform(make_vector(1,2,3), triple()) == make_vector(3,6,9));

Yet I'm not "getting it." The vector in their example contains elements all of the same type, but a major point of using fusion is containers of heterogeneous types.开发者_运维百科 What if they had used make_vector(1, 'a', "howdy") instead?

int operator()(int t)

would need to become

template<typename T> T& operator()(T& const t)

But how would I write the result_type? template<typename T> typedef T& result_type certainly isn't valid syntax, and it wouldn't make sense even if it was, because it's not tied to the function.

Usually, fusion::transform is used with a templated (or -as shown above- otherwise overloaded) function operator:

struct triple 
{ 
    template <typename Sig>
    struct result;

    template <typename This, typename T>
    struct result<This(T)>
    {
        typedef /*...figure out return type...*/ type;
    };

    template <typename T> 
    typename result<triple(T)>::type 
    operator()(T t) const 
    { 
        return 3*t;    // relies on existing operator*() for 'T'
    }
}; 

And, additional sources of information about Fusion are the examples and the test directory where you can find demonstrations of some of the techniques.

Regards Hartmut

Have you tried overloading the call operator()?

struct triple
{

    int operator()(int t) const
    {
        return t * 3;
    };
    int operator()(string t) const
    {
        return t + t + t;
    };
};