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

namespace A1 {

  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);
    }

}

namespace A2 {

  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);
    }

}

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>
#if 1
    Y<BOOST_TYPEOF(T1() * T2())>
    // In principle, this should work.
    // But it is actually not due a bug in GCC, the compiler that I use.
#else
    Y<typename A1::multiply_traits<T1, T2>::result_type>
    // This only makes the line marked with L1 work,
    // but the line marked with L2 does not work.
    // I would like to use the following command and hope
    // Koenig lookup would work for tempalte, but it is not.
    // Y<typename multiply_traits<T1, T2>::result_type>
    //
    // I'm wondering what the reason is not to have Koenig lookup
    // for templates. Is it because this problem hasn't been considered before?
    // Or it is because there is some drawback if  Koenig lookup is allowed for templates.
#endif
    operator*(const Y<T1> &y, const T2 &t) {
      return Y<T1>(y.the_t() * t);
    }
}

int main () {
  A1::X<int> x1(-2);
  A2::X<int> x2(2);
  B::Y<A1::X<int> > y1(x1);
  B::Y<A2::X<int> > y2(x2);

  std::cout << (x1 * 3).the_t() << std::endl;
  std::cout << (x2 * 3).the_t() << std::endl;
  std::cout << (y1 * 5).the_t().the_t() << std::endl; //L1
  std::cout << (y2 * 5).the_t().the_t() << std::endl; //L2
}