diff --git a/include/chaiscript/dispatchkit/boxed_cast_helper.hpp b/include/chaiscript/dispatchkit/boxed_cast_helper.hpp
index 104abc7..6347437 100644
--- a/include/chaiscript/dispatchkit/boxed_cast_helper.hpp
+++ b/include/chaiscript/dispatchkit/boxed_cast_helper.hpp
@@ -29,7 +29,8 @@ namespace chaiscript
         throw std::runtime_error("Attempted to dereference null Boxed_Value");
       }
 
-    static const void *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, const void *ptr) {
+    template<typename T>
+    static const T *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, const T *ptr) {
       if (ob.get_type_info() == ti) {
         return ptr;
       } else {
@@ -37,7 +38,8 @@ namespace chaiscript
       }
     }
 
-    static void *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, void *ptr) {
+    template<typename T>
+    static T *verify_type_no_throw(const Boxed_Value &ob, const std::type_info &ti, T *ptr) {
       if (!ob.is_const() && ob.get_type_info() == ti) {
         return ptr;
       } else {
@@ -46,7 +48,8 @@ namespace chaiscript
     }
 
 
-    static const void *verify_type(const Boxed_Value &ob, const std::type_info &ti, const void *ptr) {
+    template<typename T>
+    static const T *verify_type(const Boxed_Value &ob, const std::type_info &ti, const T *ptr) {
       if (ob.get_type_info().bare_equal_type_info(ti)) {
         return throw_if_null(ptr);
       } else {
@@ -54,7 +57,8 @@ namespace chaiscript
       }
     }
 
-    static void *verify_type(const Boxed_Value &ob, const std::type_info &ti, void *ptr) {
+    template<typename T>
+    static T *verify_type(const Boxed_Value &ob, const std::type_info &ti, T *ptr) {
       if (!ob.is_const() && ob.get_type_info().bare_equal_type_info(ti)) {
         return throw_if_null(ptr);
       } else {
diff --git a/include/chaiscript/dispatchkit/boxed_value.hpp b/include/chaiscript/dispatchkit/boxed_value.hpp
index d394d69..1e0ec99 100644
--- a/include/chaiscript/dispatchkit/boxed_value.hpp
+++ b/include/chaiscript/dispatchkit/boxed_value.hpp
@@ -243,16 +243,8 @@ namespace chaiscript
             m_data.get().m_const_data_ptr = m_ptr.get().get();
           }
 
-          Sentinel& operator=(Sentinel&&s) {
-            m_ptr = std::move(s.m_ptr);
-            m_data = std::move(s.m_data);
-          }
-
-          Sentinel(Sentinel &&s)
-            : m_ptr(std::move(s.m_ptr)),
-            m_data(std::move(s.m_data))
-          {
-          }
+          Sentinel& operator=(Sentinel&&s) = default;
+          Sentinel(Sentinel &&s) = default;
 
           operator std::shared_ptr<T>&() const
           {
diff --git a/include/chaiscript/dispatchkit/handle_return.hpp b/include/chaiscript/dispatchkit/handle_return.hpp
index ca353ec..8ac2d9e 100644
--- a/include/chaiscript/dispatchkit/handle_return.hpp
+++ b/include/chaiscript/dispatchkit/handle_return.hpp
@@ -146,6 +146,14 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<const Ret>
+        {
+          static Boxed_Value handle(const Ret &r)
+          {
+            return Boxed_Value(std::cref(r));
+          }
+        };
 
       template<typename Ret>
         struct Handle_Return<Ret &>
@@ -154,11 +162,6 @@ namespace chaiscript
           {
             return Boxed_Value(std::ref(r));
           }
-
-          static Boxed_Value handle(const Ret &r)
-          {
-            return Boxed_Value(std::cref(r));
-          }
         };
 
       template<>
diff --git a/include/chaiscript/dispatchkit/operators.hpp b/include/chaiscript/dispatchkit/operators.hpp
index 8dc54ba..4ebaec5 100644
--- a/include/chaiscript/dispatchkit/operators.hpp
+++ b/include/chaiscript/dispatchkit/operators.hpp
@@ -16,414 +16,202 @@ namespace chaiscript
   {
     namespace operators
     {
-      namespace detail
-      {
-        /// \todo make this return a decltype once we drop gcc 4.6
-        template<typename L, typename R>
-          auto assign(L l, R r) -> L&
-          {
-            return (l = r);
-          }
-
-        template<typename L, typename R>
-          auto assign_bitwise_and(L l, R r) -> decltype((l &= r))
-          {
-            return (l &= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_xor(L l, R r) -> decltype((l^=r))
-          {
-            return (l ^= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_bitwise_or(L l, R r) -> decltype((l |= r))
-          {
-            return (l |= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_difference(L l, R r) -> decltype(( l -= r))
-          {
-            return (l -= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_left_shift(L l, R r) -> decltype(( l <<= r))
-          {
-            return (l <<= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_product(L l, R r) -> decltype(( l *= r ))
-          {
-            return (l *= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_quotient(L l, R r) -> decltype(( l /= r ))
-          {
-            return (l /= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_remainder(L l, R r) -> decltype(( l %= r ))
-          {
-            return (l %= r);
-          }
-
-        template<typename L, typename R>
-          auto assign_right_shift(L l, R r) -> decltype(( l >>= r))
-          {
-            return (l >>= r);
-          }
-
-        /// \todo make this return a decltype once we drop gcc 4.6
-        template<typename L, typename R>
-          auto assign_sum(L l, R r) -> L&
-          {
-            return (l += r);
-          }
-
-        template<typename L>
-          auto prefix_decrement(L l) -> decltype(( --l ))
-          {
-            return (--l);
-          }
-
-        template<typename L>
-          auto prefix_increment(L l) -> decltype(( ++l ))
-          {
-            return (++l);
-          }
-
-        template<typename L, typename R>
-          auto equal(L l, R r) -> decltype(( l == r ))
-          {
-            return (l == r);
-          }
-
-        template<typename L, typename R>
-          auto greater_than(L l, R r) -> decltype(( l > r ))
-          {
-            return (l > r);
-          }
-
-        template<typename L, typename R>
-          auto greater_than_equal(L l, R r) -> decltype(( l >= r ))
-          {
-            return (l >= r);
-          }
-
-        template<typename L, typename R>
-          auto less_than(L l, R r) -> decltype(( l < r ))
-          {
-            return (l < r);
-          }
-
-        template<typename L, typename R>
-          auto less_than_equal(L l, R r) -> decltype(( l <= r ))
-          {
-            return (l <= r);
-          }
-
-        template<typename L>
-          auto logical_compliment(L l) -> decltype(( !l ))
-          {
-            return (!l);
-          }
-
-        template<typename L, typename R>
-          auto not_equal(L l, R r) -> decltype(( l != r ))
-          {
-            return (l != r);
-          }
-
-        template<typename L, typename R>
-          auto addition(L l, R r) -> decltype(( l + r ))
-          {
-            return (l + r);
-          }
-
-        template<typename L>
-          auto unary_plus(L l) -> decltype(( +l ))
-          {
-            return (+l);
-          }
-
-        template<typename L, typename R>
-          auto subtraction(L l, R r) -> decltype(( l - r ))
-          {
-            return (l - r);
-          }
-
-        template<typename L>
-          auto unary_minus(L l) -> decltype(( -l ))
-          {
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4146)
-            return (-l);
-#pragma warning(pop)
-#else
-            return (-l);
-#endif
-          }
-
-        template<typename L, typename R>
-          auto bitwise_and(L l, R r) -> decltype(( l & r ))
-          {
-            return (l & r);
-          }
-
-        template<typename L>
-          auto bitwise_compliment(L l) -> decltype(( ~l ))
-          {
-            return (~l);
-          }
-
-        template<typename L, typename R>
-          auto bitwise_xor(L l, R r) -> decltype(( l ^ r ))
-          {
-            return (l ^ r);
-          }
-
-        template<typename L, typename R>
-          auto bitwise_or(L l, R r) -> decltype(( l | r ))
-          {
-            return (l | r);
-          }
-
-        template<typename L, typename R>
-          auto division(L l, R r) -> decltype(( l / r ))
-          {
-            return (l / r);
-          }
-
-        template<typename L, typename R>
-          auto left_shift(L l, R r) -> decltype(( l << r ))
-          {
-            return l << r;
-          }
-
-        template<typename L, typename R>
-          auto multiplication(L l, R r) -> decltype(( l * r ))
-          {
-            return l * r;
-          }
-
-        template<typename L, typename R>
-          auto remainder(L l, R r) -> decltype(( l % r ))
-          {
-            return (l % r);
-          }
-
-        template<typename L, typename R>
-          auto right_shift(L l, R r) -> decltype(( l >> r ))
-          {
-            return (l >> r);
-          }
-      }
-
-
-
       template<typename T>
         void assign(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign<T &, const T&>), "=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs = rhs;}), "=");
         }
 
       template<typename T>
         void assign_bitwise_and(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_bitwise_and<T &, const T&>), "&=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs &= rhs;}), "&=");
         }
 
       template<typename T>
         void assign_xor(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_xor<T &, const T&>), "^=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs ^= rhs;}), "^=");
         }
 
       template<typename T>
         void assign_bitwise_or(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_bitwise_or<T &, const T&>), "|=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs |= rhs;}), "|=");
         }
 
       template<typename T>
         void assign_difference(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_difference<T &, const T&>), "-=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs -= rhs;}), "-=");
         }
 
       template<typename T>
         void assign_left_shift(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_left_shift<T &, const T&>), "<<=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "<<=");
         }
 
       template<typename T>
         void assign_product(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_product<T &, const T&>), "*=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs <<= rhs;}), "*=");
         }
 
       template<typename T>
         void assign_quotient(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_quotient<T &, const T&>), "/=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs /= rhs;}), "/=");
         }
 
       template<typename T>
         void assign_remainder(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_remainder<T &, const T&>), "%=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs %= rhs;}), "%=");
         }
 
       template<typename T>
         void assign_right_shift(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_right_shift<T &, const T&>), ">>=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs >>= rhs;}), ">>=");
         }
 
       template<typename T>
         void assign_sum(Module& m)
         {
-          m.add(chaiscript::fun(&detail::assign_sum<T &, const T&>), "+=");
+          m.add(chaiscript::fun([](T &lhs, const T&rhs)->T&{return lhs += rhs;}), "+=");
         }
 
       template<typename T>
         void prefix_decrement(Module& m)
         {
-          m.add(chaiscript::fun(&detail::prefix_decrement<T &>), "--");
+          m.add(chaiscript::fun([](T &lhs)->T&{return --lhs;}), "--");
         }
 
       template<typename T>
         void prefix_increment(Module& m)
         {
-          m.add(chaiscript::fun(&detail::prefix_increment<T &>), "++");
+          m.add(chaiscript::fun([](T &lhs)->T&{return ++lhs;}), "++");
         }
 
       template<typename T>
         void equal(Module& m)
         {
-          m.add(chaiscript::fun(&detail::equal<const T&, const T&>), "==");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs==rhs;}), "==");
         }
 
       template<typename T>
         void greater_than(Module& m)
         {
-          m.add(chaiscript::fun(&detail::greater_than<const T&, const T&>), ">");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>rhs;}), ">");
         }
 
       template<typename T>
         void greater_than_equal(Module& m)
         {
-          m.add(chaiscript::fun(&detail::greater_than_equal<const T&, const T&>), ">=");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>=rhs;}), ">=");
         }
 
       template<typename T>
         void less_than(Module& m)
         {
-          m.add(chaiscript::fun(&detail::less_than<const T&, const T&>), "<");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<rhs;}), "<");
         }
 
       template<typename T>
         void less_than_equal(Module& m)
         {
-          m.add(chaiscript::fun(&detail::less_than_equal<const T&, const T&>), "<=");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<=rhs;}), "<=");
         }
 
       template<typename T>
         void logical_compliment(Module& m)
         {
-          m.add(chaiscript::fun(&detail::logical_compliment<const T &>), "!");
+          m.add(chaiscript::fun([](const T &lhs){return !lhs;}), "!");
         }
 
       template<typename T>
         void not_equal(Module& m)
         {
-          m.add(chaiscript::fun(&detail::not_equal<const T &, const T &>), "!=");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs!=rhs;}), "!=");
         }
 
       template<typename T>
         void addition(Module& m)
         {
-          m.add(chaiscript::fun(&detail::addition<const T &, const T &>), "+");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs+rhs;}), "+");
         }
 
       template<typename T>
         void unary_plus(Module& m)
         {
-          m.add(chaiscript::fun(&detail::unary_plus<const T &>), "+");
+          m.add(chaiscript::fun([](const T &lhs){return +lhs;}), "+");
         }
 
       template<typename T>
         void subtraction(Module& m)
         {
-          m.add(chaiscript::fun(&detail::subtraction<const T &, const T &>), "-");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs-rhs;}), "-");
         }
 
       template<typename T>
         void unary_minus(Module& m)
         {
-          m.add(chaiscript::fun(&detail::unary_minus<const T &>), "-");
+          m.add(chaiscript::fun([](const T &lhs){return -lhs;}), "-");
         }
 
       template<typename T>
         void bitwise_and(Module& m)
         {
-          m.add(chaiscript::fun(&detail::bitwise_and<const T &, const T &>), "&");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs&rhs;}), "&");
         }
 
       template<typename T>
         void bitwise_compliment(Module& m)
         {
-          m.add(chaiscript::fun(&detail::bitwise_compliment<const T &>), "~");
+          m.add(chaiscript::fun([](const T &lhs){return ~lhs;}), "~");
         }
 
       template<typename T>
         void bitwise_xor(Module& m)
         {
-          m.add(chaiscript::fun(&detail::bitwise_xor<const T &, const T &>), "^");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs^rhs;}), "^");
         }
 
       template<typename T>
         void bitwise_or(Module& m)
         {
-          m.add(chaiscript::fun(&detail::bitwise_or<const T &, const T &>), "|");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs|rhs;}), "|");
         }
 
       template<typename T>
         void division(Module& m)
         {
-          m.add(chaiscript::fun(&detail::division<const T &, const T &>), "/");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs/rhs;}), "/");
         }
 
       template<typename T>
         void left_shift(Module& m)
         {
-          m.add(chaiscript::fun(&detail::left_shift<const T &, const T &>), "<<");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs<<rhs;}), "<<");
         }
 
       template<typename T>
         void multiplication(Module& m)
         {
-          m.add(chaiscript::fun(&detail::multiplication<const T &, const T &>), "*");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs*rhs;}), "*");
         }
 
       template<typename T>
         void remainder(Module& m)
         {
-          m.add(chaiscript::fun(&detail::remainder<const T &, const T &>), "%");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs%rhs;}), "%");
         }
 
       template<typename T>
         void right_shift(Module& m)
         {
-          m.add(chaiscript::fun(&detail::right_shift<const T &, const T &>), ">>");
+          m.add(chaiscript::fun([](const T &lhs, const T &rhs){return lhs>>rhs;}), ">>");
         }
     }
   }
diff --git a/include/chaiscript/dispatchkit/proxy_functions.hpp b/include/chaiscript/dispatchkit/proxy_functions.hpp
index 7a2fa28..8723d82 100644
--- a/include/chaiscript/dispatchkit/proxy_functions.hpp
+++ b/include/chaiscript/dispatchkit/proxy_functions.hpp
@@ -727,13 +727,13 @@ namespace chaiscript
         template<typename Type>
         auto do_call_impl(Class *o) const -> std::enable_if_t<!std::is_pointer<Type>::value, Boxed_Value>
         {
-          return detail::Handle_Return<const typename std::add_lvalue_reference<Type>::type>::handle(o->*m_attr);
+          return detail::Handle_Return<typename std::add_lvalue_reference<Type>::type>::handle(o->*m_attr);
         }
 
         template<typename Type>
         auto do_call_impl(const Class *o) const -> std::enable_if_t<!std::is_pointer<Type>::value, Boxed_Value>
         {
-          return detail::Handle_Return<const typename std::add_lvalue_reference<Type>::type>::handle(o->*m_attr);
+          return detail::Handle_Return<typename std::add_lvalue_reference<typename std::add_const<Type>::type>::type>::handle(o->*m_attr);
         }