diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb
index 10ef4502..04c6a0fe 100644
--- a/erb/cpp03_define.hpp.erb
+++ b/erb/cpp03_define.hpp.erb
@@ -38,12 +38,12 @@
 #define MSGPACK_ADD_ENUM(enum) \
   namespace msgpack { \
     template <> \
-    inline enum& operator>> (object const& o, enum& v) \
+    inline object const& operator>> (object const& o, enum& v) \
     { \
       int tmp; \
       o >> tmp; \
       v = static_cast<enum>(tmp); \
-      return v; \
+      return o; \
     } \
     template <> \
     inline void operator<< (object::with_zone& o, const enum& v) \
@@ -145,4 +145,3 @@ define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>,
 
 
 #endif // MSGPACK_CPP03_DEFINE_HPP
-
diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb
index 5fa95fcc..f748ccfd 100644
--- a/erb/cpp03_msgpack_tuple.hpp.erb
+++ b/erb/cpp03_msgpack_tuple.hpp.erb
@@ -133,22 +133,22 @@ tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::tr
 
 }  // namespace type
 
-inline type::tuple<>& operator>> (
+inline object const& operator>> (
         object const& o,
         type::tuple<>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
-    return v;
+    return o;
 }
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size < <%=i+1%>) { throw type_error(); }
     <%0.upto(i) {|j|%>
     o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
-    return v;
+    return o;
 }
 <%}%>
 
diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp
index e027ad51..bdfb2408 100644
--- a/include/msgpack/adaptor/bool.hpp
+++ b/include/msgpack/adaptor/bool.hpp
@@ -24,11 +24,11 @@
 namespace msgpack {
 
 
-inline bool& operator>> (object const& o, bool& v)
+inline object const& operator>> (object const& o, bool& v)
 {
     if(o.type != type::BOOLEAN) { throw type_error(); }
     v = o.via.boolean;
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -52,4 +52,3 @@ inline void operator<< (object::with_zone& o, bool v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/bool.hpp */
-
diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp
index be89559b..5c1cb3b0 100644
--- a/include/msgpack/adaptor/cpp11/array.hpp
+++ b/include/msgpack/adaptor/cpp11/array.hpp
@@ -27,7 +27,7 @@
 namespace msgpack {
 
 template <typename T, std::size_t N>
-inline std::array<T, N>& operator>> (object const& o, std::array<T, N>& v) {
+inline object const& operator>> (object const& o, std::array<T, N>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size != N) { throw type_error(); }
     if(o.via.array.size > 0) {
@@ -40,7 +40,7 @@ inline std::array<T, N>& operator>> (object const& o, std::array<T, N>& v) {
             ++it;
         } while(p < pend);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T, std::size_t N>
diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp
index 71f1e87d..a7cfcc2f 100644
--- a/include/msgpack/adaptor/cpp11/array_char.hpp
+++ b/include/msgpack/adaptor/cpp11/array_char.hpp
@@ -24,7 +24,7 @@
 namespace msgpack {
 
 template <std::size_t N>
-inline std::array<char, N>& operator>> (object const& o, std::array<char, N>& v)
+inline object const& operator>> (object const& o, std::array<char, N>& v)
 {
     switch (o.type) {
     case type::BIN:
@@ -39,7 +39,7 @@ inline std::array<char, N>& operator>> (object const& o, std::array<char, N>& v)
         throw type_error();
         break;
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, std::size_t N>
diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp
index 272a7ef3..68e5ac22 100644
--- a/include/msgpack/adaptor/cpp11/forward_list.hpp
+++ b/include/msgpack/adaptor/cpp11/forward_list.hpp
@@ -27,7 +27,7 @@
 namespace msgpack {
 
 template <typename T>
-inline std::forward_list<T>& operator>> (object const& o, std::forward_list<T>& v)
+inline object const& operator>> (object const& o, std::forward_list<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     v.resize(o.via.array.size);
@@ -36,7 +36,7 @@ inline std::forward_list<T>& operator>> (object const& o, std::forward_list<T>&
         p->convert(e);
         ++p;
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp
index 79298d6e..e29a0e17 100644
--- a/include/msgpack/adaptor/cpp11/tuple.hpp
+++ b/include/msgpack/adaptor/cpp11/tuple.hpp
@@ -76,13 +76,13 @@ struct StdTupleConverter<Tuple, 1> {
 };
 
 template <typename... Args>
-std::tuple<Args...>& operator>> (
+object const& operator>> (
     object const& o,
     std::tuple<Args...>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size < sizeof...(Args)) { throw type_error(); }
     StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return v;
+    return o;
 }
 
 // --- Convert from tuple to object with zone ---
@@ -118,4 +118,3 @@ inline void operator<< (
 } // msgpack
 
 #endif // MSGPACK_CPP11_TUPLE_HPP
-
diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp
index c6571343..f5609c88 100644
--- a/include/msgpack/adaptor/deque.hpp
+++ b/include/msgpack/adaptor/deque.hpp
@@ -25,7 +25,7 @@ namespace msgpack {
 
 
 template <typename T>
-inline std::deque<T>& operator>> (object const& o, std::deque<T>& v)
+inline object const& operator>> (object const& o, std::deque<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     v.resize(o.via.array.size);
@@ -35,7 +35,7 @@ inline std::deque<T>& operator>> (object const& o, std::deque<T>& v)
     for(; p < pend; ++p, ++it) {
         p->convert(*it);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::deque<T>& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/deque.hpp */
-
diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp
index 30090d3e..675690c2 100644
--- a/include/msgpack/adaptor/detail/cpp03_define.hpp
+++ b/include/msgpack/adaptor/detail/cpp03_define.hpp
@@ -38,12 +38,12 @@
 #define MSGPACK_ADD_ENUM(enum) \
   namespace msgpack { \
     template <> \
-    inline enum& operator>> (object const& o, enum& v) \
+    inline object const& operator>> (object const& o, enum& v) \
     { \
       int tmp; \
       o >> tmp; \
       v = static_cast<enum>(tmp); \
-      return v; \
+      return o; \
     } \
     template <> \
     inline void operator<< (object::with_zone& o, const enum& v) \
@@ -3462,4 +3462,3 @@ define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16
 
 
 #endif // MSGPACK_CPP03_DEFINE_HPP
-
diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
index e3c45006..d17fd703 100644
--- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
+++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
@@ -10580,26 +10580,26 @@ tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
 
 }  // namespace type
 
-inline type::tuple<>& operator>> (
+inline object const& operator>> (
         object const& o,
         type::tuple<>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
-    return v;
+    return o;
 }
 
 template <typename A0>
-type::tuple<A0>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size < 1) { throw type_error(); }
     
     o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1>
-type::tuple<A0, A1>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10607,11 +10607,11 @@ type::tuple<A0, A1>& operator>> (
     
     o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
     o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2>
-type::tuple<A0, A1, A2>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10620,11 +10620,11 @@ type::tuple<A0, A1, A2>& operator>> (
     o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
     o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
     o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3>
-type::tuple<A0, A1, A2, A3>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10634,11 +10634,11 @@ type::tuple<A0, A1, A2, A3>& operator>> (
     o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
     o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
     o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-type::tuple<A0, A1, A2, A3, A4>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10649,11 +10649,11 @@ type::tuple<A0, A1, A2, A3, A4>& operator>> (
     o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
     o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
     o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-type::tuple<A0, A1, A2, A3, A4, A5>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10665,11 +10665,11 @@ type::tuple<A0, A1, A2, A3, A4, A5>& operator>> (
     o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
     o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
     o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-type::tuple<A0, A1, A2, A3, A4, A5, A6>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10682,11 +10682,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6>& operator>> (
     o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
     o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
     o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10700,11 +10700,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& operator>> (
     o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
     o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
     o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10719,11 +10719,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& operator>> (
     o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
     o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
     o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10739,11 +10739,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& operator>> (
     o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
     o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
     o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10760,11 +10760,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& operator>> (
     o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
     o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
     o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10782,11 +10782,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& operator>> (
     o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
     o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
     o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10805,11 +10805,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& operator>> (
     o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
     o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
     o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10829,11 +10829,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& operato
     o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
     o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
     o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10854,11 +10854,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& op
     o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
     o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
     o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10880,11 +10880,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
     o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
     o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10907,11 +10907,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
     o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
     o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10935,11 +10935,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
     o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
     o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10964,11 +10964,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
     o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
     o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -10994,11 +10994,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
     o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
     o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11025,11 +11025,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
     o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
     o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11057,11 +11057,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
     o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
     o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11090,11 +11090,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
     o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
     o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11124,11 +11124,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
     o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
     o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11159,11 +11159,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
     o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
     o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11195,11 +11195,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
     o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
     o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11232,11 +11232,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
     o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
     o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11270,11 +11270,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
     o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
     o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11309,11 +11309,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
     o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
     o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11349,11 +11349,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
     o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
     o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11390,11 +11390,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
     o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
     o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>());
-    return v;
+    return o;
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
-type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& operator>> (
+object const& operator>> (
         object const& o,
         type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
@@ -11432,7 +11432,7 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
     o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
     o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>());
     o.via.array.ptr[31].convert<typename type::tuple_type<A31>::type>(v.template get<31>());
-    return v;
+    return o;
 }
 
 
diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp
index 712b08cf..795a1184 100644
--- a/include/msgpack/adaptor/detail/cpp11_define.hpp
+++ b/include/msgpack/adaptor/detail/cpp11_define.hpp
@@ -40,12 +40,12 @@
 #define MSGPACK_ADD_ENUM(enum) \
   namespace msgpack { \
     template <> \
-    inline enum& operator>> (object const& o, enum& v) \
+    inline object const& operator>> (object const& o, enum& v) \
     { \
       int tmp; \
       o >> tmp; \
       v = static_cast<enum>(tmp);   \
-      return v; \
+      return o; \
     } \
     template <> \
     inline void operator<< (object::with_zone& o, const enum& v) \
diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
index 7335e12e..4dee4602 100644
--- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
+++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
@@ -140,13 +140,13 @@ struct MsgpackTupleConverter<Tuple, 1> {
 };
 
 template <typename... Args>
-type::tuple<Args...>& operator>> (
+object const& operator>> (
     object const& o,
     type::tuple<Args...>& v) {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size < sizeof...(Args)) { throw type_error(); }
     MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return v;
+    return o;
 }
 
 // --- Convert from tuple to object with zone ---
@@ -182,4 +182,3 @@ inline void operator<< (
 } // msgpack
 
 #endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP
-
diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp
index 6acbc132..3deccd10 100644
--- a/include/msgpack/adaptor/fixint.hpp
+++ b/include/msgpack/adaptor/fixint.hpp
@@ -54,30 +54,30 @@ typedef fix_int<int64_t> fix_int64;
 }  // namespace type
 
 
-inline type::fix_int8& operator>> (object const& o, type::fix_int8& v)
-    { v = type::detail::convert_integer<int8_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_int8& v)
+    { v = type::detail::convert_integer<int8_t>(o); return o; }
 
-inline type::fix_int16& operator>> (object const& o, type::fix_int16& v)
-    { v = type::detail::convert_integer<int16_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_int16& v)
+    { v = type::detail::convert_integer<int16_t>(o); return o; }
 
-inline type::fix_int32& operator>> (object const& o, type::fix_int32& v)
-    { v = type::detail::convert_integer<int32_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_int32& v)
+    { v = type::detail::convert_integer<int32_t>(o); return o; }
 
-inline type::fix_int64& operator>> (object const& o, type::fix_int64& v)
-    { v = type::detail::convert_integer<int64_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_int64& v)
+    { v = type::detail::convert_integer<int64_t>(o); return o; }
 
 
-inline type::fix_uint8& operator>> (object const& o, type::fix_uint8& v)
-    { v = type::detail::convert_integer<uint8_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_uint8& v)
+    { v = type::detail::convert_integer<uint8_t>(o); return o; }
 
-inline type::fix_uint16& operator>> (object const& o, type::fix_uint16& v)
-    { v = type::detail::convert_integer<uint16_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_uint16& v)
+    { v = type::detail::convert_integer<uint16_t>(o); return o; }
 
-inline type::fix_uint32& operator>> (object const& o, type::fix_uint32& v)
-    { v = type::detail::convert_integer<uint32_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_uint32& v)
+    { v = type::detail::convert_integer<uint32_t>(o); return o; }
 
-inline type::fix_uint64& operator>> (object const& o, type::fix_uint64& v)
-    { v = type::detail::convert_integer<uint64_t>(o); return v; }
+inline object const& operator>> (object const& o, type::fix_uint64& v)
+    { v = type::detail::convert_integer<uint64_t>(o); return o; }
 
 
 template <typename Stream>
@@ -169,4 +169,3 @@ inline void operator<< (object::with_zone& o, type::fix_uint64 v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/fixint.hpp */
-
diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp
index b49767c4..16470e4b 100644
--- a/include/msgpack/adaptor/float.hpp
+++ b/include/msgpack/adaptor/float.hpp
@@ -27,7 +27,7 @@ namespace msgpack {
 // FIXME check overflow, underflow
 
 
-inline float& operator>> (object const& o, float& v)
+inline object const& operator>> (object const& o, float& v)
 {
     if(o.type == type::DOUBLE) {
         v = static_cast<float>(o.via.dec);
@@ -41,7 +41,7 @@ inline float& operator>> (object const& o, float& v)
     else {
         throw type_error();
     }
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -52,7 +52,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
 }
 
 
-inline double& operator>> (object const& o, double& v)
+inline object const& operator>> (object const& o, double& v)
 {
     if(o.type == type::DOUBLE) {
         v = o.via.dec;
@@ -66,7 +66,7 @@ inline double& operator>> (object const& o, double& v)
     else {
         throw type_error();
     }
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -99,4 +99,3 @@ inline void operator<< (object::with_zone& o, double v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/float.hpp */
-
diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp
index 27ae7031..726bf7d3 100644
--- a/include/msgpack/adaptor/int.hpp
+++ b/include/msgpack/adaptor/int.hpp
@@ -117,40 +117,40 @@ namespace detail {
 }  // namespace detail
 }  // namespace type
 
-inline char& operator>> (object const& o, char& v)
-    { v = type::detail::convert_integer<char>(o); return v; }
+inline object const& operator>> (object const& o, char& v)
+    { v = type::detail::convert_integer<char>(o); return o; }
 
 
-inline signed char& operator>> (object const& o, signed char& v)
-    { v = type::detail::convert_integer<signed char>(o); return v; }
+inline object const& operator>> (object const& o, signed char& v)
+    { v = type::detail::convert_integer<signed char>(o); return o; }
 
-inline signed short& operator>> (object const& o, signed short& v)
-    { v = type::detail::convert_integer<signed short>(o); return v; }
+inline object const& operator>> (object const& o, signed short& v)
+    { v = type::detail::convert_integer<signed short>(o); return o; }
 
-inline signed int& operator>> (object const& o, signed int& v)
-    { v = type::detail::convert_integer<signed int>(o); return v; }
+inline object const& operator>> (object const& o, signed int& v)
+    { v = type::detail::convert_integer<signed int>(o); return o; }
 
-inline signed long& operator>> (object const& o, signed long& v)
-    { v = type::detail::convert_integer<signed long>(o); return v; }
+inline object const& operator>> (object const& o, signed long& v)
+    { v = type::detail::convert_integer<signed long>(o); return o; }
 
-inline signed long long& operator>> (object const& o, signed long long& v)
-    { v = type::detail::convert_integer<signed long long>(o); return v; }
+inline object const& operator>> (object const& o, signed long long& v)
+    { v = type::detail::convert_integer<signed long long>(o); return o; }
 
 
-inline unsigned char& operator>> (object const& o, unsigned char& v)
-    { v = type::detail::convert_integer<unsigned char>(o); return v; }
+inline object const& operator>> (object const& o, unsigned char& v)
+    { v = type::detail::convert_integer<unsigned char>(o); return o; }
 
-inline unsigned short& operator>> (object const& o, unsigned short& v)
-    { v = type::detail::convert_integer<unsigned short>(o); return v; }
+inline object const& operator>> (object const& o, unsigned short& v)
+    { v = type::detail::convert_integer<unsigned short>(o); return o; }
 
-inline unsigned int& operator>> (object const& o, unsigned int& v)
-    { v = type::detail::convert_integer<unsigned int>(o); return v; }
+inline object const& operator>> (object const& o, unsigned int& v)
+    { v = type::detail::convert_integer<unsigned int>(o); return o; }
 
-inline unsigned long& operator>> (object const& o, unsigned long& v)
-    { v = type::detail::convert_integer<unsigned long>(o); return v; }
+inline object const& operator>> (object const& o, unsigned long& v)
+    { v = type::detail::convert_integer<unsigned long>(o); return o; }
 
-inline unsigned long long& operator>> (object const& o, unsigned long long& v)
-    { v = type::detail::convert_integer<unsigned long long>(o); return v; }
+inline object const& operator>> (object const& o, unsigned long long& v)
+    { v = type::detail::convert_integer<unsigned long long>(o); return o; }
 
 
 template <typename Stream>
@@ -276,4 +276,3 @@ inline void operator<< (object::with_zone& o, const unsigned long long& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/int.hpp */
-
diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp
index 04633a9d..048eae00 100644
--- a/include/msgpack/adaptor/list.hpp
+++ b/include/msgpack/adaptor/list.hpp
@@ -25,7 +25,7 @@ namespace msgpack {
 
 
 template <typename T>
-inline std::list<T>& operator>> (object const& o, std::list<T>& v)
+inline object const& operator>> (object const& o, std::list<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     v.resize(o.via.array.size);
@@ -35,7 +35,7 @@ inline std::list<T>& operator>> (object const& o, std::list<T>& v)
     for(; p < pend; ++p, ++it) {
         p->convert(*it);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::list<T>& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/list.hpp */
-
diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp
index ed2fb059..5cf61762 100644
--- a/include/msgpack/adaptor/map.hpp
+++ b/include/msgpack/adaptor/map.hpp
@@ -43,7 +43,7 @@ namespace detail {
 
 
 template <typename K, typename V>
-inline type::assoc_vector<K,V>& operator>> (object const& o, type::assoc_vector<K,V>& v)
+inline object const& operator>> (object const& o, type::assoc_vector<K,V>& v)
 {
     if(o.type != type::MAP) { throw type_error(); }
     v.resize(o.via.map.size);
@@ -55,7 +55,7 @@ inline type::assoc_vector<K,V>& operator>> (object const& o, type::assoc_vector<
         p->val.convert(it->second);
     }
     std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
-    return v;
+    return o;
 }
 
 template <typename Stream, typename K, typename V>
@@ -94,7 +94,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
 
 
 template <typename K, typename V>
-inline std::map<K, V>& operator>> (object const& o, std::map<K, V>& v)
+inline object const& operator>> (object const& o, std::map<K, V>& v)
 {
     if(o.type != type::MAP) { throw type_error(); }
     object_kv* p(o.via.map.ptr);
@@ -111,7 +111,7 @@ inline std::map<K, V>& operator>> (object const& o, std::map<K, V>& v)
             v.insert(it, std::pair<K,V>(key, val));
         }
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename K, typename V>
@@ -150,7 +150,7 @@ inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
 
 
 template <typename K, typename V>
-inline std::multimap<K, V>& operator>> (object const& o, std::multimap<K, V>& v)
+inline object const& operator>> (object const& o, std::multimap<K, V>& v)
 {
     if(o.type != type::MAP) { throw type_error(); }
     object_kv* p(o.via.map.ptr);
@@ -161,7 +161,7 @@ inline std::multimap<K, V>& operator>> (object const& o, std::multimap<K, V>& v)
         p->val.convert(value.second);
         v.insert(value);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename K, typename V>
diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp
index bef57fc5..9f8a12ea 100644
--- a/include/msgpack/adaptor/nil.hpp
+++ b/include/msgpack/adaptor/nil.hpp
@@ -29,10 +29,10 @@ struct nil { };
 }  // namespace type
 
 
-inline type::nil& operator>> (object const& o, type::nil& v)
+inline object const& operator>> (object const& o, type::nil& v)
 {
     if(o.type != type::NIL) { throw type_error(); }
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -62,4 +62,3 @@ inline void object::as<void>() const
 }  // namespace msgpack
 
 #endif /* msgpack/type/nil.hpp */
-
diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp
index a309cac7..851d00c3 100644
--- a/include/msgpack/adaptor/pair.hpp
+++ b/include/msgpack/adaptor/pair.hpp
@@ -25,13 +25,13 @@ namespace msgpack {
 
 
 template <typename T1, typename T2>
-inline std::pair<T1, T2>& operator>> (object const& o, std::pair<T1, T2>& v)
+inline object const& operator>> (object const& o, std::pair<T1, T2>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     if(o.via.array.size != 2) { throw type_error(); }
     o.via.array.ptr[0].convert(v.first);
     o.via.array.ptr[1].convert(v.second);
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T1, typename T2>
@@ -58,4 +58,3 @@ inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/pair.hpp */
-
diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp
index 0d41b846..e2268607 100644
--- a/include/msgpack/adaptor/raw.hpp
+++ b/include/msgpack/adaptor/raw.hpp
@@ -61,12 +61,12 @@ struct raw_ref {
 }  // namespace type
 
 
-inline type::raw_ref& operator>> (object const& o, type::raw_ref& v)
+inline object const& operator>> (object const& o, type::raw_ref& v)
 {
     if(o.type != type::BIN) { throw type_error(); }
     v.ptr  = o.via.bin.ptr;
     v.size = o.via.bin.size;
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -91,4 +91,3 @@ inline void operator<< (object::with_zone& o, const type::raw_ref& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/raw.hpp */
-
diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp
index bea26203..f949944e 100644
--- a/include/msgpack/adaptor/set.hpp
+++ b/include/msgpack/adaptor/set.hpp
@@ -25,7 +25,7 @@ namespace msgpack {
 
 
 template <typename T>
-inline std::set<T>& operator>> (object const& o, std::set<T>& v)
+inline object const& operator>> (object const& o, std::set<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     object* p = o.via.array.ptr + o.via.array.size;
@@ -34,7 +34,7 @@ inline std::set<T>& operator>> (object const& o, std::set<T>& v)
         --p;
         v.insert(p->as<T>());
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -71,7 +71,7 @@ inline void operator<< (object::with_zone& o, const std::set<T>& v)
 
 
 template <typename T>
-inline std::multiset<T>& operator>> (object const& o, std::multiset<T>& v)
+inline object const& operator>> (object const& o, std::multiset<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     object* p = o.via.array.ptr + o.via.array.size;
@@ -80,7 +80,7 @@ inline std::multiset<T>& operator>> (object const& o, std::multiset<T>& v)
         --p;
         v.insert(p->as<T>());
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -119,4 +119,3 @@ inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/set.hpp */
-
diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp
index 19964a54..a1ea2f8c 100644
--- a/include/msgpack/adaptor/string.hpp
+++ b/include/msgpack/adaptor/string.hpp
@@ -24,7 +24,7 @@
 namespace msgpack {
 
 
-inline std::string& operator>> (object const& o, std::string& v)
+inline object const& operator>> (object const& o, std::string& v)
 {
     switch (o.type) {
     case type::BIN:
@@ -37,7 +37,7 @@ inline std::string& operator>> (object const& o, std::string& v)
         throw type_error();
         break;
     }
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -68,4 +68,3 @@ inline void operator<< (object& o, const std::string& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/string.hpp */
-
diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp
index ebd0d67a..6495fa9b 100644
--- a/include/msgpack/adaptor/tr1/unordered_map.hpp
+++ b/include/msgpack/adaptor/tr1/unordered_map.hpp
@@ -44,7 +44,7 @@ namespace msgpack {
 
 
 template <typename K, typename V>
-inline MSGPACK_STD_TR1::unordered_map<K, V>& operator>> (object o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
+inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
 {
     if(o.type != type::MAP) { throw type_error(); }
     object_kv* p(o.via.map.ptr);
@@ -54,7 +54,7 @@ inline MSGPACK_STD_TR1::unordered_map<K, V>& operator>> (object o, MSGPACK_STD_T
         p->key.convert(key);
         p->val.convert(v[key]);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename K, typename V>
@@ -93,7 +93,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
 
 
 template <typename K, typename V>
-inline MSGPACK_STD_TR1::unordered_multimap<K, V>& operator>> (object o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
+inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
 {
     if(o.type != type::MAP) { throw type_error(); }
     object_kv* p(o.via.map.ptr);
@@ -104,7 +104,7 @@ inline MSGPACK_STD_TR1::unordered_multimap<K, V>& operator>> (object o, MSGPACK_
         p->val.convert(value.second);
         v.insert(value);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename K, typename V>
diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp
index bf7fc7c8..e6086c09 100644
--- a/include/msgpack/adaptor/tr1/unordered_set.hpp
+++ b/include/msgpack/adaptor/tr1/unordered_set.hpp
@@ -43,7 +43,7 @@ namespace msgpack {
 
 
 template <typename T>
-inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_set<T>& v)
+inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     object* p = o.via.array.ptr + o.via.array.size;
@@ -52,7 +52,7 @@ inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1:
         --p;
         v.insert(p->as<T>());
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -89,7 +89,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s
 
 
 template <typename T>
-inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
+inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     object* p = o.via.array.ptr + o.via.array.size;
@@ -98,7 +98,7 @@ inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD
         --p;
         v.insert(p->as<T>());
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -139,4 +139,3 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
 #undef MSGPACK_STD_TR1
 
 #endif /* msgpack/type/set.hpp */
-
diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp
index 0123a3b6..73856896 100644
--- a/include/msgpack/adaptor/vector.hpp
+++ b/include/msgpack/adaptor/vector.hpp
@@ -25,7 +25,7 @@ namespace msgpack {
 
 
 template <typename T>
-inline std::vector<T>& operator>> (object const& o, std::vector<T>& v)
+inline object const& operator>> (object const& o, std::vector<T>& v)
 {
     if(o.type != type::ARRAY) { throw type_error(); }
     v.resize(o.via.array.size);
@@ -39,7 +39,7 @@ inline std::vector<T>& operator>> (object const& o, std::vector<T>& v)
             ++it;
         } while(p < pend);
     }
-    return v;
+    return o;
 }
 
 template <typename Stream, typename T>
@@ -78,4 +78,3 @@ inline void operator<< (object::with_zone& o, const std::vector<T>& v)
 }  // namespace msgpack
 
 #endif /* msgpack/type/vector.hpp */
-
diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp
index 9ada3e6c..d87081d0 100644
--- a/include/msgpack/adaptor/vector_char.hpp
+++ b/include/msgpack/adaptor/vector_char.hpp
@@ -23,7 +23,7 @@
 
 namespace msgpack {
 
-inline std::vector<char>& operator>> (object const& o, std::vector<char>& v)
+inline object const& operator>> (object const& o, std::vector<char>& v)
 {
     switch (o.type) {
     case type::BIN:
@@ -38,7 +38,7 @@ inline std::vector<char>& operator>> (object const& o, std::vector<char>& v)
         throw type_error();
         break;
     }
-    return v;
+    return o;
 }
 
 template <typename Stream>
@@ -69,4 +69,3 @@ inline void operator<< (object::with_zone& o, const std::vector<char>& v)
 }  // namespace msgpack
 
 #endif // MSGPACK_TYPE_VECTOR_CHAR_HPP
-
diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp
index 4b05cc23..f060450b 100644
--- a/include/msgpack/object.hpp
+++ b/include/msgpack/object.hpp
@@ -188,18 +188,18 @@ inline packer<Stream>& packer<Stream>::pack(const T& v)
     return *this;
 }
 
-inline object& operator>> (object const& o, object& v)
+inline object const& operator>> (object const& o, object& v)
 {
     v = o;
-    return v;
+    return o;
 }
 
 // convert operator
 template <typename T>
-inline T& operator>> (object const& o, T& v)
+inline object const& operator>> (object const& o, T& v)
 {
     v.msgpack_unpack(o.convert());
-    return v;
+    return o;
 }
 
 namespace detail {