#include <boost/typeof/typeof.hpp>
#include <iostream>

namespace A {

  template <typename T>
    class X {
      public:
        X() { }
        X(T t) : _t(t) { }
        const T &the_t() const { return _t; }
      private:
        T _t;
    };

  template <typename T1, typename T2>
    struct multiply_traits;

  template <typename T1, typename T2>
    struct multiply_traits<X<T1>, T2> {
      typedef X<T1> result_type;
    };

  template <typename T1, typename T2>
    typename multiply_traits<X<T1>, T2>::result_type operator*(const X<T1> &x, const T2 &t) {
      return X<T1>(x.the_t() * t);
    }

  template<class T>
    T make();

  template<class T1, class T2>
    struct multiply_traits {
      BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, make<T1>() * make<T2>())
        typedef typename nested::type type;
    };

}

namespace B {

  template <typename T>
    class Y {
      public:
        Y(T t) : _t(t) { }
        const T &the_t() const { return _t; }
      private:
        T _t;
    };

  template <typename T1, typename T2>
//  Y<typename A::multiply_traits<T1, T2>::result_type>
#if 0
 I do not want to write in the above way.
      Because if I write in the above way, 'multiply_traits' has to be in namespace A. 
     If the types T1 and T2 are not in namespace A, it would be awkward to defined 'multiply_traits' for them in namespace A.
     This is why I want the following way of deriving the template argument to Y, which does not need specify the namespace at all.
     The result type is derived from the function argument types directly.
     But it would end up with a compiler bug.
     My original question is still not addressed.
     Would you please take a further look on how to solve this problem?
     Or it can not be solved at this moment? 
#endif
  Y<BOOST_TYPEOF(T1() * T2())>
    operator*(const Y<T1> &y, const T2 &t) {
      return Y<T1>(y.the_t() * t);
    }
}

int main () {
  A::X<int> x(2);
  B::Y<A::X<int> > y(x);

  std::cout << (x * 3).the_t() << std::endl;
  std::cout << (y * 5).the_t().the_t() << std::endl;
}