template curiosity

[chameleon]

Just for curiosity:
Is there a way to avoid this rarely annoying case?

template<typename T>
inline VectorT<T> operator*(T s, const VectorT<T> &v) { return v * s; }

int main()
{
   VectorT<double> v;
   v = 2 * v;                // FAIL! must be: v = 2.0 * v; or else it search for const VectorT<int>
   .......

I think something like this but I realize that no substitution can happen.

template<typename T>
inline VectorT<T> operator*(VectorT<T>::value_type s, const VectorT<T> &v) { return v * s; }

I think also this but it creates namespace pollution, right?

template<typename C>
inline C operator*(typename C::value_type s, C &v) { return v * s; }

[JLBorges]

Perhaps the simplest way is to use two type parameters for the template:

template < typename T, typename U >
inline VectorT<T> operator*( const U& mult, const VectorT<T>& seq ) 
{ return seq * mult ; }