rice 4.6.1 → 4.7.0

data/include/rice/stl.hpp

@@ -17,14 +17,17 @@ namespace Rice::stl
 // so define it for Ruby if necessary
 namespace Rice::stl
 {
-  inline Class rb_cStlException;
-
-  inline void define_stl_exception()
+  inline void define_stl_exceptions()
   {
     Module rb_mStd = define_module("Std");
-    rb_cStlException = define_class_under<std::exception>(rb_mStd, "Exception", rb_eStandardError).
-                        define_constructor(Constructor<std::exception>()).
-                        define_method("message", &std::exception::what);
+
+    define_class_under<std::exception>(rb_mStd, "Exception", rb_eStandardError).
+      define_constructor(Constructor<std::exception>()).
+      define_method("message", &std::exception::what);
+
+    define_class_under<std::runtime_error>(rb_mStd, "RuntimeError", rb_eRuntimeError).
+      define_constructor(Constructor<std::runtime_error, const char*>()).
+      define_method("message", &std::runtime_error::what);
   }
 }
 
@@ -35,7 +38,17 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      Rice::stl::define_stl_exception();
+      Rice::stl::define_stl_exceptions();
+      return true;
+    }
+  };
+
+  template<>
+  struct Type<std::runtime_error>
+  {
+    static bool verify()
+    {
+      Rice::stl::define_stl_exceptions();
       return true;
     }
   };
@@ -90,59 +103,186 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<int N>
+  struct Type<std::string[N]>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<std::string*>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      using Pointer_T = Pointer<std::string>;
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Pointer_T>();
+      return pair.first;
+    }
+  };
+
+  template<>
+  struct Type<std::string**>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      using Pointer_T = Pointer<std::string*>;
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Pointer_T>();
+      return pair.first;
+    }
   };
 
   template<>
   class To_Ruby<std::string>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
+  template<int N>
+  class To_Ruby<std::string[N]>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(std::string data[N])
+    {
+      Buffer<std::string> buffer(data, N);
+      Data_Object<Buffer<std::string>> dataObject(std::move(buffer));
+      return dataObject.value();
+    }
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string*>
   {
   public:
-    VALUE convert(const std::string* x)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
     {
-      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+
+    VALUE convert(const std::string* value)
+    {
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      bool isBuffer = this->returnInfo_ && this->returnInfo_->isBuffer();
+
+      if (isBuffer)
+      {
+        using Pointer_T = Pointer<std::string>;
+        return detail::wrap(Data_Type<Pointer_T>::klass(), Data_Type<Pointer_T>::ruby_data_type(), value, isOwner);
+      }
+      else
+      {
+        return detail::protect(rb_external_str_new, value->data(), (long)value->size());
+      }
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string*&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string* x)
     {
       return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
-  template<>
+  /*template<>
   class To_Ruby<std::string**>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::string** data)
     {
       Buffer<std::string*> buffer(data);
       Data_Object<Buffer<std::string*>> dataObject(std::move(buffer));
       return dataObject.value();
     }
-  };
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };*/
 
   template<>
   class From_Ruby<std::string>
@@ -168,7 +308,7 @@ namespace Rice::detail
 
     std::string convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       return std::string(RSTRING_PTR(value), RSTRING_LEN(value));
     }
 
@@ -200,7 +340,7 @@ namespace Rice::detail
 
     std::string& convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
       return this->converted_;
     }
@@ -210,10 +350,50 @@ namespace Rice::detail
     std::string converted_ = "";
   };
 
+  template<>
+  class From_Ruby<std::string&&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string&& convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
+      return std::move(this->converted_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::string converted_ = "";
+  };
+
   template<>
   class From_Ruby<std::string*>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -228,12 +408,13 @@ namespace Rice::detail
 
     std::string* convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
       return &this->converted_;
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::string converted_;
   };
 }
@@ -253,6 +434,11 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
   };
 
   template<>
@@ -323,12 +509,23 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cComplex;
+    }
   };
 
   template<typename T>
   class To_Ruby<std::complex<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::complex<T>& data)
     {
       std::vector<VALUE> args(2);
@@ -336,12 +533,21 @@ namespace Rice::detail
       args[1] = To_Ruby<T>().convert(data.imag());
       return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::complex<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::complex<T>& data)
     {
       std::vector<VALUE> args(2);
@@ -349,12 +555,21 @@ namespace Rice::detail
       args[1] = To_Ruby<T>().convert(data.imag());
       return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::complex<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -380,6 +595,12 @@ namespace Rice::detail
   class From_Ruby<std::complex<T>&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -407,6 +628,46 @@ namespace Rice::detail
 }
 
 
+// =========   filesystem.hpp   =========
+
+
+// ---------   filesystem.ipp   ---------
+#include <filesystem>
+
+namespace Rice
+{
+  namespace stl
+  {
+    inline void define_filesystem_path()
+    {
+      Module rb_mStd = define_module("Std");
+      Module rb_mFileSystem = define_module_under(rb_mStd, "Filesystem");
+
+      define_class_under<std::filesystem::path>(rb_mFileSystem, "Path").
+        define_constructor(Constructor<std::filesystem::path>()).
+        define_constructor(Constructor<std::filesystem::path, std::string>());
+    }
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::filesystem::path>
+  {
+    static bool verify()
+    {
+      if (!Data_Type<std::filesystem::path>::is_defined())
+      {
+        Rice::stl::define_filesystem_path();
+      }
+
+      return true;
+    }
+  };
+}
+
+
 // =========   optional.hpp   =========
 
 
@@ -422,23 +683,44 @@ namespace Rice::detail
     {
       return Type<intrinsic_type<T>>::verify();
     }
+
+    static VALUE rubyKlass()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   };
 
   template<>
   class To_Ruby<std::nullopt_t>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::nullopt_t& _)
     {
       return Qnil;
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::optional<T>>
   {
   public:
-    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(std::optional<T>& data)
     {
       if (data.has_value())
       {
@@ -449,13 +731,22 @@ namespace Rice::detail
         return Qnil;
       }
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::optional<T>&>
   {
   public:
-    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::optional<T>& data)
     {
       if (data.has_value())
       {
@@ -466,12 +757,21 @@ namespace Rice::detail
         return Qnil;
       }
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::optional<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -501,6 +801,12 @@ namespace Rice::detail
   class From_Ruby<std::optional<T>&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -546,22 +852,43 @@ namespace Rice::detail
     {
       return Type<T>::verify();
     }
+
+    static VALUE rubyKlass()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   };
 
   template<typename T>
   class To_Ruby<std::reference_wrapper<T>>
   {
   public:
-    VALUE convert(const std::reference_wrapper<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::reference_wrapper<T>& data)
     {
       return To_Ruby<T&>().convert(data.get());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::reference_wrapper<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return this->converter_.is_convertible(value);
@@ -600,78 +927,43 @@ namespace Rice
     public:
       PairHelper(Data_Type<T> klass) : klass_(klass)
       {
-        this->define_constructor();
-        this->define_copyable_methods();
-        this->define_access_methods();
-        this->define_modify_methods();
+        this->define_constructors();
+        this->define_attributes();
         this->define_to_s();
       }
 
     private:
-      void define_constructor()
+      void define_constructors()
       {
-        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+        klass_.define_constructor(Constructor<T>())
+              .define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+      
+        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+        {
+          klass_.define_constructor(Constructor<T, const T&>());
+        }
       }
 
-      void define_copyable_methods()
+      void define_attributes()
       {
-        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+        // Access methods
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::first_type>>>)
         {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              return pair;
-            });
+          klass_.define_attr("first", &T::first, Rice::AttrAccess::Read);
         }
         else
         {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              throw std::runtime_error("Cannot copy pair with non-copy constructible types");
-              return pair;
-            });
+          klass_.define_attr("first", &T::first, Rice::AttrAccess::ReadWrite);
         }
-      }
-
-      void define_access_methods()
-      {
-        // Access methods
-        klass_.define_method("first", [](T& pair) -> typename T::first_type&
-          {
-            return pair.first;
-          })
-        .define_method("second", [](T& pair) -> typename T::second_type&
-          {
-            return pair.second;
-          });
-      }
 
-      void define_modify_methods()
-      {
-        // Access methods
-        klass_.define_method("first=", [](T& pair, typename T::first_type& value) -> typename T::first_type&
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::second_type>>>)
         {
-          if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::first_type>>>)
-          {
-            throw std::runtime_error("Cannot set pair.first since it is a constant");
-          }
-          else
-          {
-            pair.first = value;
-            return pair.first;
-          }
-        })
-        .define_method("second=", [](T& pair, typename T::second_type& value) -> typename T::second_type&
+          klass_.define_attr("second", &T::second, Rice::AttrAccess::Read);
+        }
+        else
         {
-          if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::second_type>>>)
-          {
-            throw std::runtime_error("Cannot set pair.second since it is a constant");
-          }
-          else
-          {
-            pair.second = value;
-            return pair.second;
-          }
-        });
+          klass_.define_attr("second", &T::second, Rice::AttrAccess::ReadWrite);
+        }
       }
 
       void define_to_s()
@@ -707,8 +999,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Pair_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Pair_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -777,8 +1069,7 @@ namespace Rice
       MapHelper(Data_Type<T> klass) : klass_(klass)
       {
         this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
@@ -795,27 +1086,13 @@ namespace Rice
         define_pair<const Key_T, Mapped_T>();
       }
 
-      void define_constructor()
+      void define_constructors()
       {
         klass_.define_constructor(Constructor<T>());
-      }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              return map;
-            });
-        }
-        else
-        {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              throw std::runtime_error("Cannot copy maps with non-copy constructible types");
-              return map;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -998,8 +1275,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Map_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Map_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -1176,6 +1453,12 @@ namespace Rice
     class From_Ruby<std::map<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -1221,6 +1504,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::map<T, U> converted_;
     };
   }
@@ -1241,32 +1525,62 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cNilClass;
+    }
   };
 
   template<>
   class To_Ruby<std::monostate>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::monostate& _)
     {
       return Qnil;
     }
+
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::monostate&>
   {
   public:
-    static VALUE convert(const std::monostate& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::monostate& data)
     {
       return Qnil;
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<std::monostate>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return value == Qnil ? Convertible::Exact : Convertible::None;
@@ -1289,6 +1603,12 @@ namespace Rice::detail
   class From_Ruby<std::monostate&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return value == Qnil ? Convertible::Exact : Convertible::None;
@@ -1345,8 +1665,7 @@ namespace Rice
       MultimapHelper(Data_Type<T> klass) : klass_(klass)
       {
         this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
@@ -1362,27 +1681,13 @@ namespace Rice
         define_pair<const Key_T, Mapped_T>();
       }
 
-      void define_constructor()
+      void define_constructors()
       {
         klass_.define_constructor(Constructor<T>());
-      }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
-        {
-          klass_.define_method("copy", [](T& multimap) -> T
-            {
-              return multimap;
-            });
-        }
-        else
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& multimap) -> T
-            {
-              throw std::runtime_error("Cannot copy multimaps with non-copy constructible types");
-              return multimap;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -1400,14 +1705,14 @@ namespace Rice
       {
         // Access methods
         klass_.
-          define_method("[]", [](const T& multimap, const Key_T& key) -> Array
+          define_method("[]", [](T& multimap, const Key_T& key) -> Array
           {
             Array result;
             auto range = multimap.equal_range(key);
 
             for (auto iter = range.first; iter != range.second; iter++)
             {
-              result.push<Mapped_T>(iter->second);
+              result.push(iter->second, false);
             }
 
             return result;
@@ -1510,7 +1815,8 @@ namespace Rice
               auto iter = multimap.begin();
 
               std::stringstream stream;
-              stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+              detail::TypeMapper<T> typeMapper;
+              stream << "<" << typeMapper.rubyName() << ":";
               stream << "{";
 
               for (; iter != multimap.end(); iter++)
@@ -1548,8 +1854,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(MultiMap_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<MultiMap_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -1723,6 +2029,12 @@ namespace Rice
     class From_Ruby<std::multimap<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -1768,6 +2080,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::multimap<T, U> converted_;
     };
   }
@@ -1961,9 +2274,9 @@ namespace Rice
         klass_.define_method("to_a", [](T& self) -> VALUE
         {
           Array array;
-          for (const Value_T& element: self)
+          for (auto element: self)
           {
-            array.push(element);
+            array.push(element, false);
           }
 
           return array.value();
@@ -1980,7 +2293,8 @@ namespace Rice
             auto finish = self.end();
 
             std::stringstream stream;
-            stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+            detail::TypeMapper<T> typeMapper;
+            stream << "<" << typeMapper.rubyName() << ":";
             stream << "{";
 
             for (; iter != finish; iter++)
@@ -2021,8 +2335,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Set_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Set_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -2053,11 +2367,11 @@ namespace Rice
         return Qnil;
       };
       
-      using NativeFunction_T = NativeFunction<void, decltype(block), false>;
+      using Proc_T = decltype(block);
+      using NativeProc_T = NativeProc<Proc_T>;
+      std::unique_ptr<NativeProc_T> proc(NativeProc_T::define(std::forward<Proc_T>(block)));
 
-      // It is ok to use the address of native because it will remain valid while we iterate the set
-      NativeFunction_T native(block);
-      detail::protect<Function_T>(rb_block_call, rubySet, identifier.id(), 0, nullptr, NativeFunction_T::procEntry, (VALUE)&native);
+      detail::protect<Function_T>(rb_block_call, rubySet, identifier.id(), 0, nullptr, NativeProc_T::resolve, (VALUE)proc.get());
       
       return result;
     }
@@ -2218,6 +2532,12 @@ namespace Rice
     private:
       static inline std::string setName = "Set";
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -2274,6 +2594,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::set<T> converted_;
     };
   }
@@ -2319,8 +2640,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(SharedPtr_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<SharedPtr_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -2373,7 +2694,29 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      return Type<T>::verify();
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return Type<Pointer<T>>::verify();
+        return Type<Buffer<T>>::verify();
+      }
+      else
+      {
+        return Type<T>::verify();
+      }
+    }
+
+    static VALUE rubyKlass()
+    {
+      if (Data_Type<std::shared_ptr<T>>::is_defined())
+      {
+        std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<std::shared_ptr<T>>();
+        return pair.first;
+      }
+      else
+      {
+        TypeMapper<T> typeMapper;
+        return typeMapper.rubyKlass();
+      }
     }
   };
 
@@ -2381,11 +2724,17 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arv)
+    {
+    }
+
     VALUE convert(std::shared_ptr<T>& data)
     {
       if constexpr (std::is_fundamental_v<T>)
       {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
       }
       else
       {
@@ -2397,7 +2746,7 @@ namespace Rice::detail
     {
       if constexpr (std::is_fundamental_v<T>)
       {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
       }
       else
       {
@@ -2442,10 +2791,10 @@ namespace Rice::detail
         std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
         return *ptr;
       }
-      else if constexpr (std::is_fundamental_v<T>)
+      else if (std::is_fundamental_v<T>)
       {
         // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
         return wrapper->data();
       }
       else
@@ -2463,16 +2812,15 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg)
+    {
+    }
+
     VALUE convert(std::shared_ptr<T>& data)
     {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-      }
-      else
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-      }
+      return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
     }
   };
 
@@ -2512,10 +2860,10 @@ namespace Rice::detail
         std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
         return *ptr;
       }
-      else if constexpr (std::is_fundamental_v<T>)
+      else if (std::is_fundamental_v<T>)
       {
         // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
         return wrapper->data();
       }
       else
@@ -2557,42 +2905,65 @@ namespace Rice::detail
       auto indices = std::make_index_sequence<std::tuple_size_v<std::tuple<Types...>>>{};
       return verifyTypes(indices);
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cArray;
+    }
   };
 
   template<typename...Types>
   class To_Ruby<std::tuple<Types...>>
   {
   public:
-    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::tuple<Types...>& data)
     {
       Array result;
 
       for_each_tuple(data, [&](auto element)
       {
-        using Element_T = decltype(element);
-        result.push<Element_T>((Element_T)element);
+        result.push(element, true);
       });
 
       return result.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class To_Ruby<std::tuple<Types...>&>
   {
   public:
-    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::tuple<Types...>& data)
     {
       Array result;
 
-      for_each_tuple(data, [&](auto& value)
-        {
-          VALUE element = detail::To_Ruby<decltype(value)>().convert(value);
-          result.push(element);
-        });
+      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
+
+      for_each_tuple(data, [&](auto& element)
+      {
+        result.push(element, isOwner);
+      });
 
       return result.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
@@ -2607,6 +2978,12 @@ namespace Rice::detail
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       Convertible result = Convertible::None;
@@ -2756,27 +3133,37 @@ namespace Rice::detail
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
 
-    template<std::size_t... I>
     constexpr static bool verify()
     {
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
       return verifyTypes(indices);
     }
+
+    static VALUE rubyKlass()
+    {
+      // There is no direct mapping to Ruby, so just return Object
+      return rb_cObject;
+    }
   };
 
   template<typename...Types>
   class To_Ruby<std::variant<Types...>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
     template<typename U, typename V>
-    static VALUE convertElement(U& data, bool takeOwnership)
+    VALUE convertElement(U& data, bool takeOwnership)
     {
       return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
     }
 
     template<typename U, std::size_t... I>
-    static VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -2819,26 +3206,36 @@ namespace Rice::detail
     }
 
     template<typename U>
-    static VALUE convert(U& data, bool takeOwnership = false)
+    VALUE convert(U& data)
     {
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, true, indices);
     }
 
     template<typename U>
-    static VALUE convert(U&& data, bool takeOwnership = false)
+    VALUE convert(U&& data)
     {
+      bool isOwner = true;
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, isOwner, indices);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class To_Ruby<std::variant<Types...>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     template<typename U, typename V>
-    static VALUE convertElement(U& data, bool takeOwnership)
+    VALUE convertElement(U& data, bool takeOwnership)
     {
       if constexpr (std::is_const_v<U>)
       {
@@ -2851,7 +3248,7 @@ namespace Rice::detail
     }
 
     template<typename U, std::size_t... I>
-    static VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -2875,17 +3272,27 @@ namespace Rice::detail
     }
 
     template<typename U>
-    static VALUE convert(U& data, bool takeOwnership = false)
+    VALUE convert(U& data)
     {
+      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, isOwner, indices);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class From_Ruby<std::variant<Types...>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       Convertible result = Convertible::None;
@@ -2972,6 +3379,12 @@ namespace Rice::detail
   class From_Ruby<std::variant<Types...>&> : public From_Ruby<std::variant<Types...>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     std::variant<Types...>& convert(VALUE value)
     {
       int index = this->figureIndex(value);
@@ -3037,6 +3450,12 @@ namespace Rice::detail
   class To_Ruby<std::unique_ptr<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::unique_ptr<T>& data)
     {
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
@@ -3048,17 +3467,29 @@ namespace Rice::detail
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
       return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template <typename T>
   class To_Ruby<std::unique_ptr<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::unique_ptr<T>& data)
     {
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, std::move(data), true);
+      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template <typename T>
@@ -3071,6 +3502,12 @@ namespace Rice::detail
       return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       if (!is_same_smart_ptr(value))
@@ -3108,6 +3545,12 @@ namespace Rice::detail
       return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       if (!is_same_smart_ptr(value))
@@ -3140,7 +3583,21 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      return Type<T>::verify();
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return Type<Pointer<T>>::verify();
+        return Type<Buffer<T>>::verify();
+      }
+      else
+      {
+        return Type<T>::verify();
+      }
+    }
+
+    static VALUE rubyKlass()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
     }
   };
 }
@@ -3177,8 +3634,7 @@ namespace Rice
       UnorderedMapHelper(Data_Type<T> klass) : klass_(klass)
       {
         this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
@@ -3195,27 +3651,13 @@ namespace Rice
         define_pair<const Key_T, T>();
       }
 
-      void define_constructor()
+      void define_constructors()
       {
         klass_.define_constructor(Constructor<T>());
-      }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
-        {
-          klass_.define_method("copy", [](T& unordered_map) -> T
-            {
-              return unordered_map;
-            });
-        }
-        else
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& unordered_map) -> T
-            {
-              throw std::runtime_error("Cannot copy unordered_maps with non-copy constructible types");
-              return unordered_map;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -3398,8 +3840,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(UnorderedMap_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<UnorderedMap_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -3576,6 +4018,12 @@ namespace Rice
     class From_Ruby<std::unordered_map<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -3621,6 +4069,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::unordered_map<T, U> converted_;
     };
   }
@@ -3676,12 +4125,10 @@ namespace Rice
       // Helper method to translate Ruby indices to vector indices
       Difference_T normalizeIndex(Size_T size, Difference_T index, bool enforceBounds = false)
       {
-        // Negative indices mean count from the right. Note that negative indices
-        // wrap around!
-        if (index < 0)
+        // Negative indices mean count from the right
+        if (index < 0 && (-index <= size))
         {
-          index = ((-index) % size);
-          index = index > 0 ? size - index : index;
+          index = size + index;
         }
 
         if (enforceBounds && (index < 0 || index >= (Difference_T)size))
@@ -3694,9 +4141,13 @@ namespace Rice
 
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, Size_T, const Parameter_T>())
-              .define_constructor(Constructor<T, const T&>());
+        klass_.define_constructor(Constructor<T>());
+
+        if constexpr (std::is_copy_constructible_v<Value_T>)
+        {
+          klass_.define_constructor(Constructor<T, const T&>())
+                .define_constructor(Constructor<T, Size_T, const Parameter_T>());
+        }
 
         if constexpr (std::is_default_constructible_v<Value_T>)
         {
@@ -3758,42 +4209,85 @@ namespace Rice
 
       void define_access_methods()
       {
-        // Access methods
-        klass_.define_method("first", [](const T& vector) -> std::optional<Value_T>
+        if constexpr (!std::is_same_v<Value_T, bool>)
         {
-          if (vector.size() > 0)
-          {
-            return vector.front();
-          }
-          else
+          // Access methods
+          klass_.define_method("first", [](T& vector) -> std::optional<std::reference_wrapper<Value_T>>
           {
-            return std::nullopt;
-          }
-        })
-        .define_method("last", [](const T& vector) -> std::optional<Value_T>
-        {
-          if (vector.size() > 0)
+            if (vector.size() > 0)
+            {
+              return vector.front();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("last", [](T& vector) -> std::optional<std::reference_wrapper<Value_T>>
           {
-            return vector.back();
-          }
-          else
+            if (vector.size() > 0)
+            {
+              return vector.back();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("[]", [this](T& vector, Difference_T index) -> std::optional<std::reference_wrapper<Value_T>>
           {
-            return std::nullopt;
-          }
-        })
-        .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
+            index = normalizeIndex(vector.size(), index);
+            if (index < 0 || index >= (Difference_T)vector.size())
+            {
+              return std::nullopt;
+            }
+            else
+            {
+              return vector[index];
+            }
+          })
+          .template define_method<Value_T*(T::*)()>("data", &T::data, Return().setBuffer());
+        }
+        else
         {
-          index = normalizeIndex(vector.size(), index);
-          if (index < 0 || index >= (Difference_T)vector.size())
+          // Access methods
+          klass_.define_method("first", [](T& vector) -> std::optional<Value_T>
           {
-            return std::nullopt;
-          }
-          else
+            if (vector.size() > 0)
+            {
+              return vector.front();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("last", [](T& vector) -> std::optional<Value_T>
           {
-            return vector[index];
-          }
-        })
-        .define_method("[]", [this](const T& vector, Difference_T start, Difference_T length) -> VALUE
+            if (vector.size() > 0)
+            {
+              return vector.back();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("[]", [this](T& vector, Difference_T index) -> std::optional<Value_T>
+          {
+            index = normalizeIndex(vector.size(), index);
+            if (index < 0 || index >= (Difference_T)vector.size())
+            {
+              return std::nullopt;
+            }
+            else
+            {
+              return vector[index];
+            }
+          });
+        }
+
+        klass_.define_method("[]", [this](T& vector, Difference_T start, Difference_T length) -> VALUE
         {
           start = normalizeIndex(vector.size(), start);
           if (start < 0 || start >= (Difference_T)vector.size())
@@ -3812,25 +4306,19 @@ namespace Rice
             }
 
             auto finish = vector.begin() + start + length;
-            T slice(begin, finish);
 
             VALUE result = rb_ary_new();
-            std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
+            for (auto iter = begin; iter != finish; iter++)
             {
-              VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+              const Reference_T element = *iter;
+              VALUE value = detail::To_Ruby<Reference_T>().convert(element);
               rb_ary_push(result, value);
-            });
+            }
 
             return result;
           }
         }, Return().setValue());
 
-        if constexpr (!std::is_same_v<Value_T, bool>)
-        {
-          define_buffer<Value_T>();
-          klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
-        }
-
         rb_define_alias(klass_, "at", "[]");
       }
 
@@ -3840,35 +4328,39 @@ namespace Rice
         if constexpr (detail::is_comparable_v<T>)
         {
           klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
+          {
+            auto iter = std::find(vector.begin(), vector.end(), element);
+            if (iter == vector.end())
             {
-              auto iter = std::find(vector.begin(), vector.end(), element);
-              if (iter == vector.end())
-              {
-                return std::nullopt;
-              }
-              else
-              {
-                Value_T result = *iter;
-                vector.erase(iter);
-                return result;
-              }
-            })
-          .define_method("include?", [](T& vector, Parameter_T element)
+              return std::nullopt;
+            }
+            else if constexpr (std::is_copy_assignable_v<Value_T>)
             {
-              return std::find(vector.begin(), vector.end(), element) != vector.end();
-            })
+              Value_T result = *iter;
+              vector.erase(iter);
+              return result;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("include?", [](T& vector, Parameter_T element)
+          {
+            return std::find(vector.begin(), vector.end(), element) != vector.end();
+          })
           .define_method("index", [](T& vector, Parameter_T element) -> std::optional<Difference_T>
+          {
+            auto iter = std::find(vector.begin(), vector.end(), element);
+            if (iter == vector.end())
             {
-              auto iter = std::find(vector.begin(), vector.end(), element);
-              if (iter == vector.end())
-              {
-                return std::nullopt;
-              }
-              else
-              {
-                return iter - vector.begin();
-              }
-            });
+              return std::nullopt;
+            }
+            else
+            {
+              return iter - vector.begin();
+            }
+          });
         }
         else
         {
@@ -3890,45 +4382,65 @@ namespace Rice
       void define_modify_methods()
       {
         klass_.define_method("clear", &T::clear)
-          .define_method("delete_at", [](T& vector, const size_t& pos)
+          .define_method("delete_at", [](T& vector, const size_t& pos) -> std::optional<Value_T>
+          {
+            auto iter = vector.begin() + pos;
+
+            if constexpr (std::is_copy_assignable_v<Value_T>)
             {
-              auto iter = vector.begin() + pos;
               Value_T result = *iter;
               vector.erase(iter);
               return result;
-            })
+            }
+            else
+            {
+              vector.erase(iter);
+              return std::nullopt;
+            }
+          })
           .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
+          {
+            int normalized = normalizeIndex(vector.size(), index, true);
+            // For a Ruby array a positive index means insert the element before the index. But
+            // a negative index means insert the element *after* the index. std::vector
+            // inserts *before* the index. So add 1 if this is a negative index.
+            if (index < 0)
             {
-              index = normalizeIndex(vector.size(), index, true);
-              auto iter = vector.begin() + index;
-              vector.insert(iter, element);
-              return vector;
-            })
+              normalized++;
+            }
+            auto iter = vector.begin() + normalized;
+            vector.insert(iter, std::move(element));
+            return vector;
+          })
           .define_method("pop", [](T& vector) -> std::optional<Value_T>
+          {
+            if constexpr (!std::is_copy_assignable_v<Value_T>)
             {
-              if (vector.size() > 0)
-              {
-                Value_T result = vector.back();
-                vector.pop_back();
-                return result;
-              }
-              else
-              {
-                return std::nullopt;
-              }
-            })
-          .define_method("push", [](T& vector, Parameter_T element) -> T&
+              vector.pop_back();
+              return std::nullopt;
+            }
+            else if (vector.empty())
             {
-              vector.push_back(element);
-              return vector;
-            })
-          .define_method("shrink_to_fit", &T::shrink_to_fit)
-          .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> Parameter_T
+              return std::nullopt;
+            }
+            else
             {
-              index = normalizeIndex(vector.size(), index, true);
-              vector[index] = element;
-              return element;
-            });
+              Value_T result = vector.back();
+              vector.pop_back();
+              return result;
+            }
+          })
+          .define_method("push", [](T& vector, Parameter_T element) -> T&
+          {
+            vector.push_back(std::move(element));
+            return vector;
+          })
+        .define_method("shrink_to_fit", &T::shrink_to_fit)
+        .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> void
+          {
+            index = normalizeIndex(vector.size(), index, true);
+            vector[index] = std::move(element);
+          });
 
         rb_define_alias(klass_, "push_back", "push");
         rb_define_alias(klass_, "<<", "push");
@@ -3949,7 +4461,7 @@ namespace Rice
           VALUE result = rb_ary_new();
           std::for_each(vector.begin(), vector.end(), [&result](const Reference_T element)
           {
-            VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+            VALUE value = detail::To_Ruby<Reference_T>().convert(element);
             rb_ary_push(result, value);
           });
 
@@ -4007,8 +4519,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Vector_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Vector_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -4160,6 +4672,12 @@ namespace Rice
     class From_Ruby<std::vector<T>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -4207,6 +4725,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::vector<T> converted_;
     };
   }
@@ -4218,10 +4737,19 @@ namespace Rice
     class To_Ruby<std::vector<bool>::reference>
     {
     public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
       VALUE convert(const std::vector<bool>::reference& value)
       {
         return value ? Qtrue : Qfalse;
       }
+
+    private:
+      Return* returnInfo_ = nullptr;
     };
   }
 }