rice 4.3.3 → 4.6.0

data/include/rice/stl.hpp

@@ -2,6 +2,79 @@
 #define Rice__stl__hpp_
 
 
+// =========   exception.hpp   =========
+
+namespace Rice::stl
+{
+  extern Class rb_cStlException;
+}
+
+
+// ---------   exception.ipp   ---------
+#include <exception>
+
+// Libraries sometime inherit custom exception objects from std::exception,
+// so define it for Ruby if necessary
+namespace Rice::stl
+{
+  inline Class rb_cStlException;
+
+  inline void define_stl_exception()
+  {
+    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);
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::exception>
+  {
+    static bool verify()
+    {
+      Rice::stl::define_stl_exception();
+      return true;
+    }
+  };
+}
+
+
+// =========   exception_ptr.hpp   =========
+
+
+// ---------   exception_ptr.ipp   ---------
+#include <exception>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::exception_ptr> define_exception_ptr()
+  {
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::exception_ptr>(rb_mStd, "ExceptionPtr");
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::exception_ptr>
+  {
+    static bool verify()
+    {
+      if (!Data_Type<std::exception_ptr>::is_defined())
+      {
+        stl::define_exception_ptr();
+      }
+
+      return true;
+    }
+  };
+}
+
+
 // =========   string.hpp   =========
 
 
@@ -23,7 +96,7 @@ namespace Rice::detail
   class To_Ruby<std::string>
   {
   public:
-    VALUE convert(std::string const& x)
+    VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
@@ -33,46 +106,46 @@ namespace Rice::detail
   class To_Ruby<std::string&>
   {
   public:
-    VALUE convert(std::string const& x)
+    VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
   };
 
   template<>
-  class From_Ruby<std::string>
+  class To_Ruby<std::string*>
   {
   public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    VALUE convert(const std::string* x)
     {
+      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+  };
 
-    bool is_convertible(VALUE value)
+  template<>
+  class To_Ruby<std::string*&>
+  {
+  public:
+    VALUE convert(const std::string* x)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+  };
 
-    std::string convert(VALUE value)
+  template<>
+  class To_Ruby<std::string**>
+  {
+  public:
+    VALUE convert(std::string** data)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<std::string>();
-      }
-      else
-      {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        return std::string(RSTRING_PTR(value), RSTRING_LEN(value));
-      }
+      Buffer<std::string*> buffer(data);
+      Data_Object<Buffer<std::string*>> dataObject(std::move(buffer));
+      return dataObject.value();
     }
-
-  private:
-    Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<std::string&>
+  class From_Ruby<std::string>
   {
   public:
     From_Ruby() = default;
@@ -81,57 +154,76 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
-    std::string& convert(VALUE value)
+    std::string convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<std::string>();
-      }
-      else
-      {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
-        return this->converted_;
-      }
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      return std::string(RSTRING_PTR(value), RSTRING_LEN(value));
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::string converted_;
   };
 
   template<>
-  class From_Ruby<std::string*>
+  class From_Ruby<std::string&>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_STRING;
     }
 
-    std::string* convert(VALUE value)
+    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 &this->converted_;
+      return this->converted_;
     }
 
   private:
-    std::string converted_;
+    Arg* arg_ = nullptr;
+    std::string converted_ = "";
   };
 
   template<>
-  class From_Ruby<std::string*&>
+  class From_Ruby<std::string*>
   {
   public:
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
     std::string* convert(VALUE value)
@@ -193,22 +285,22 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
     std::string_view convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<std::string_view>();
-      }
-      else
-      {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        return std::string_view(RSTRING_PTR(value), RSTRING_LEN(value));
-      }
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      return std::string_view(RSTRING_PTR(value), RSTRING_LEN(value));
     }
 
   private:
@@ -222,7 +314,6 @@ namespace Rice::detail
 // ---------   complex.ipp   ---------
 #include <complex>
 
-
 namespace Rice::detail
 {
   template<typename T>
@@ -247,10 +338,35 @@ namespace Rice::detail
     }
   };
 
+  template<typename T>
+  class To_Ruby<std::complex<T>&>
+  {
+  public:
+    VALUE convert(const std::complex<T>& data)
+    {
+      std::vector<VALUE> args(2);
+      args[0] = To_Ruby<T>().convert(data.real());
+      args[1] = To_Ruby<T>().convert(data.imag());
+      return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
+    }
+  };
+
   template<typename T>
   class From_Ruby<std::complex<T>>
   {
   public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_COMPLEX:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
     std::complex<T> convert(VALUE value)
     {
       VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
@@ -258,17 +374,24 @@ namespace Rice::detail
 
       return std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
     }
-
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_COMPLEX;
-    }
   };
 
   template<typename T>
   class From_Ruby<std::complex<T>&>
   {
   public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_COMPLEX:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
     std::complex<T>& convert(VALUE value)
     {
       VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
@@ -278,11 +401,6 @@ namespace Rice::detail
       return this->converted_;
     }
 
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_COMPLEX;
-    }
-
   private:
     std::complex<T> converted_;
   };
@@ -310,7 +428,7 @@ namespace Rice::detail
   class To_Ruby<std::nullopt_t>
   {
   public:
-    VALUE convert(std::nullopt_t& _)
+    VALUE convert(const std::nullopt_t& _)
     {
       return Qnil;
     }
@@ -354,6 +472,18 @@ namespace Rice::detail
   class From_Ruby<std::optional<T>>
   {
   public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+          break;
+        default:
+          return From_Ruby<T>().is_convertible(value);
+      }
+    }
+
     std::optional<T> convert(VALUE value)
     {
       if (value == Qnil)
@@ -371,6 +501,18 @@ namespace Rice::detail
   class From_Ruby<std::optional<T>&>
   {
   public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+          break;
+        default:
+          return From_Ruby<T>().is_convertible(value);
+      }
+    }
+
     std::optional<T>& convert(VALUE value)
     {
       if (value == Qnil)
@@ -383,7 +525,6 @@ namespace Rice::detail
       }
       return this->converted_;
     }
-    
   private:
     std::optional<T> converted_;
   };
@@ -421,9 +562,9 @@ namespace Rice::detail
   class From_Ruby<std::reference_wrapper<T>>
   {
   public:
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return true;
+      return this->converter_.is_convertible(value);
     }
 
     std::reference_wrapper<T> convert(VALUE value)
@@ -437,1166 +578,2585 @@ namespace Rice::detail
 }
 
 
-// =========   smart_ptr.hpp   =========
-
+// =========   pair.hpp   =========
 
-namespace Rice::detail
+namespace Rice
 {
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  class WrapperSmartPointer : public Wrapper
-  {
-  public:
-    WrapperSmartPointer(SmartPointer_T<Arg_Ts...> data);
-    ~WrapperSmartPointer();
-    void* get() override;
-    SmartPointer_T<Arg_Ts...>& data();
-
-  private:
-    SmartPointer_T<Arg_Ts...> data_;
-  };
+  template<typename T1, typename T2>
+  Data_Type<std::pair<T1, T2>> define_pair(std::string klassName = "");
 }
 
 
-// ---------   smart_ptr.ipp   ---------
-
-#include <assert.h>
-#include <memory>
+// ---------   pair.ipp   ---------
+#include <utility>
 
-namespace Rice::detail
+namespace Rice
 {
-  // ---- WrapperSmartPointer ------
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::WrapperSmartPointer(SmartPointer_T<Arg_Ts...> data) 
-    : data_(std::move(data))
-  {
-  }
-
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::~WrapperSmartPointer()
-  {
-    Registries::instance.instances.remove(this->get());
-  }
-
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline void* WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::get()
-  {
-    return (void*)this->data_.get();
-  }
-
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline SmartPointer_T<Arg_Ts...>& WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::data()
-  {
-    return data_;
-  }
-
-  // ---- unique_ptr ------
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>>
-  {
-  public:
-    VALUE convert(std::unique_ptr<T>& data)
-    {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-
-      // Use custom wrapper type 
-      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
-      return detail::wrap<std::unique_ptr<T>, Wrapper_T>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
-    }
-  };
-
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>&>
+  namespace stl
   {
-  public:
-    VALUE convert(std::unique_ptr<T>& data)
+    template<typename T>
+    class PairHelper
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
+    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_to_s();
+      }
 
-      // Use custom wrapper type 
-      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
-      return detail::wrap<std::unique_ptr<T>, Wrapper_T>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
-    }
-  };
+    private:
+      void define_constructor()
+      {
+        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+      }
 
-  template <typename T>
-  class From_Ruby<std::unique_ptr<T>&>
-  {
-  public:
-    std::unique_ptr<T>& convert(VALUE value)
-    {
-      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      void define_copyable_methods()
+      {
+        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+        {
+          klass_.define_method("copy", [](T& pair) -> T
+            {
+              return pair;
+            });
+        }
+        else
+        {
+          klass_.define_method("copy", [](T& pair) -> T
+            {
+              throw std::runtime_error("Cannot copy pair with non-copy constructible types");
+              return pair;
+            });
+        }
+      }
 
-      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
+      void define_access_methods()
       {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
+        // 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;
+          });
       }
-      return smartWrapper->data();
-    }
-  };
 
-  template<typename T>
-  struct Type<std::unique_ptr<T>>
+      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::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&
+        {
+          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;
+          }
+        });
+      }
+
+      void define_to_s()
+      {
+        if constexpr (detail::is_ostreamable_v<typename T::first_type> && detail::is_ostreamable_v<typename T::second_type>)
+        {
+          klass_.define_method("to_s", [](const T& pair)
+            {
+              std::stringstream stream;
+              stream << "[" << pair.first << ", " << pair.second << "]";
+              return stream.str();
+            });
+        }
+        else
+        {
+          klass_.define_method("to_s", [](const T& pair)
+            {
+              return "[Not printable]";
+            });
+        }
+      }
+
+      private:
+        Data_Type<T> klass_;
+    };
+  } // namespace
+
+  template<typename T1, typename T2>
+  Data_Type<std::pair<T1, T2>> define_pair(std::string klassName)
+  {
+    using Pair_T = std::pair<T1, T2>;
+    using Data_Type_T = Data_Type<Pair_T>;
+
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(Pair_T));
+      klassName = detail::rubyClassName(typeName);
+    }
+
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
+    }
+
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<Pair_T>>(rb_mStd, id);
+    stl::PairHelper helper(result);
+    return result;
+  }
+
+  namespace detail
+  {
+    template<typename T1, typename T2>
+    struct Type<std::pair<T1, T2>>
+    {
+      static bool verify()
+      {
+        detail::verifyType<T1>();
+        detail::verifyType<T2>();
+
+        if (!Data_Type<std::pair<T1, T2>>::is_defined())
+        {
+          define_pair<T1, T2>();
+        }
+
+        return true;
+      }
+    };
+  }
+}
+
+
+
+// =========   map.hpp   =========
+
+namespace Rice
+{
+  template<typename K, typename T>
+  Data_Type<std::map<K, T>> define_map(std::string name = "");
+}
+
+
+// ---------   map.ipp   ---------
+#include <map>
+
+namespace Rice
+{
+  namespace stl
+  {
+    template<typename T>
+    class MapHelper
+    {
+      using Key_T = typename T::key_type;
+      using Mapped_T = typename T::mapped_type;
+      using Value_T = typename T::value_type;
+      using Reference_T = typename T::reference;
+      using Size_T = typename T::size_type;
+      using Difference_T = typename T::difference_type;
+      using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+
+    public:
+      MapHelper(Data_Type<T> klass) : klass_(klass)
+      {
+        this->register_pair();
+        this->define_constructor();
+        this->define_copyable_methods();
+        this->define_capacity_methods();
+        this->define_access_methods();
+        this->define_comparable_methods();
+        this->define_modify_methods();
+        this->define_enumerable();
+        this->define_to_s();
+        this->define_to_hash();
+      }
+
+    private:
+
+      void register_pair()
+      {
+        define_pair<const Key_T, Mapped_T>();
+      }
+
+      void define_constructor()
+      {
+        klass_.define_constructor(Constructor<T>());
+      }
+
+      void define_copyable_methods()
+      {
+        if constexpr (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;
+            });
+        }
+      }
+
+      void define_capacity_methods()
+      {
+        klass_.define_method("empty?", &T::empty)
+          .define_method("max_size", &T::max_size)
+          .define_method("size", &T::size);
+        
+        rb_define_alias(klass_, "count", "size");
+        rb_define_alias(klass_, "length", "size");
+      }
+
+      void define_access_methods()
+      {
+        // Access methods
+        klass_.define_method("[]", [](const T& map, const Key_T& key) -> std::optional<Mapped_T>
+          {
+            auto iter = map.find(key);
+
+            if (iter != map.end())
+            {
+              return iter->second;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("include?", [](T& map, Key_T& key) -> bool
+          {
+              return map.find(key) != map.end();
+          })
+          .define_method("keys", [](T& map) -> std::vector<Key_T>
+            {
+              std::vector<Key_T> result;
+              std::transform(map.begin(), map.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.first;
+                });
+
+              return result;
+            })
+          .define_method("values", [](T& map) -> std::vector<Mapped_T>
+            {
+              std::vector<Mapped_T> result;
+              std::transform(map.begin(), map.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.second;
+                });
+
+              return result;
+            });
+
+            rb_define_alias(klass_, "has_key", "include?");
+      }
+
+      // Methods that require Value_T to support operator==
+      void define_comparable_methods()
+      {
+        if constexpr (detail::is_comparable_v<Mapped_T>)
+        {
+          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
+            {
+              auto it = std::find_if(map.begin(), map.end(),
+              [&value](auto& pair)
+                {
+                  return pair.second == value;
+                });
+
+              return it != map.end();
+          });
+        }
+        else
+        {
+          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
+          {
+              return false;
+          });
+        }
+
+        rb_define_alias(klass_, "has_value", "value?");
+      }
+
+      void define_modify_methods()
+      {
+        klass_.define_method("clear", &T::clear)
+          .define_method("delete", [](T& map, Key_T& key) -> std::optional<Mapped_T>
+            {
+              auto iter = map.find(key);
+
+              if (iter != map.end())
+              {
+                Mapped_T result = iter->second;
+                map.erase(iter);
+                return result;
+              }
+              else
+              {
+                return std::nullopt;
+              }
+            })
+          .define_method("[]=", [](T& map, Key_T key, Mapped_T& value) -> Mapped_T
+            {
+              map[key] = value;
+              return value;
+            });
+
+          rb_define_alias(klass_, "store", "[]=");
+      }
+
+      void define_enumerable()
+      {
+        // Add enumerable support
+        klass_.template define_iterator<typename T::iterator (T::*)()>(&T::begin, &T::end);
+      }
+
+      void define_to_hash()
+      {
+        // Add enumerable support
+        klass_.define_method("to_h", [](T& map)
+        {
+          VALUE result = rb_hash_new();
+          std::for_each(map.begin(), map.end(), [&result](const Reference_T pair)
+          {
+            VALUE key = detail::To_Ruby<Key_T&>().convert(pair.first);
+            VALUE value = detail::To_Ruby<To_Ruby_T&>().convert(pair.second);
+            rb_hash_aset(result, key, value);
+          });
+
+          return result;
+        }, Return().setValue());
+      }
+
+      void define_to_s()
+      {
+        if constexpr (detail::is_ostreamable_v<Key_T> && detail::is_ostreamable_v<Mapped_T>)
+        {
+          klass_.define_method("to_s", [](const T& map)
+            {
+              auto iter = map.begin();
+
+              std::stringstream stream;
+              stream << "{";
+
+              for (; iter != map.end(); iter++)
+              {
+                if (iter != map.begin())
+                {
+                  stream << ", ";
+                }
+                stream << iter->first << " => " << iter->second;
+              }
+
+              stream << "}";
+              return stream.str();
+            });
+        }
+        else
+        {
+          klass_.define_method("to_s", [](const T& map)
+            {
+              return "[Not printable]";
+            });
+        }
+      }
+
+      private:
+        Data_Type<T> klass_;
+    };
+  } // namespace
+
+  template<typename Key, typename T>
+  Data_Type<std::map<Key, T>> define_map(std::string klassName)
+  {
+    using Map_T = std::map<Key, T>;
+    using Data_Type_T = Data_Type<Map_T>;
+
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(Map_T));
+      klassName = detail::rubyClassName(typeName);
+    }
+
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
+    }
+
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<Map_T>>(rb_mStd, id);
+    stl::MapHelper helper(result);
+    return result;
+  }
+
+  namespace detail
+  {
+    template<typename Key_T, typename T>
+    struct Type<std::map<Key_T, T>>
+    {
+      static bool verify()
+      {
+        Type<Key_T>::verify();
+        Type<T>::verify();
+
+        if (!Data_Type<std::map<Key_T, T>>::is_defined())
+        {
+          define_map<Key_T, T>();
+        }
+
+        return true;
+      }
+    };
+
+    template<typename T, typename U>
+    struct MapFromHash
+    {
+      static int convertPair(VALUE key, VALUE value, VALUE user_data)
+      {
+        std::map<T, U>* result = (std::map<T, U>*)(user_data);
+
+        // This method is being called from Ruby so we cannot let any C++ 
+        // exceptions propogate back to Ruby
+        return cpp_protect([&]
+        {
+          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          return ST_CONTINUE;
+        });
+      }
+
+      static std::map<T, U> convert(VALUE value)
+      {
+        std::map<T, U> result;
+        VALUE user_data = (VALUE)(&result);
+
+        // MSVC needs help here, but g++ does not
+        using Rb_Hash_ForEach_T = void(*)(VALUE, int(*)(VALUE, VALUE, VALUE), VALUE);
+        detail::protect<Rb_Hash_ForEach_T>(rb_hash_foreach, value, convertPair, user_data);
+
+        return result;
+      }
+    };
+
+    template<typename T, typename U>
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::map<T, U> convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped map (hopefully!)
+            return *detail::unwrap<std::map<T, U>>(value, Data_Type<std::map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby hash and the mapped type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              return MapFromHash<T, U>::convert(value);
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::map");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<typename T, typename U>
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::map<T, U>& convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped map (hopefully!)
+            return *detail::unwrap<std::map<T, U>>(value, Data_Type<std::map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the map type is copyable
+            if constexpr (std::is_default_constructible_v<std::map<T, U>>)
+            {
+              this->converted_ = MapFromHash<T, U>::convert(value);
+              return this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::map");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+      std::map<T, U> converted_;
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::map<T, U>*>
+    {
+    public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::map<T, U>* convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped map (hopefully!)
+            return detail::unwrap<std::map<T, U>>(value, Data_Type<std::map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the map type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              this->converted_ = MapFromHash<T, U>::convert(value);
+              return &this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::map");
+          }
+        }
+      }
+
+    private:
+      std::map<T, U> converted_;
+    };
+  }
+}
+
+// =========   monostate.hpp   =========
+
+
+// ---------   monostate.ipp   ---------
+#include <variant>
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::monostate>
+  {
+    constexpr static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<std::monostate>
+  {
+  public:
+    VALUE convert(const std::monostate& _)
+    {
+      return Qnil;
+    }
+  };
+
+  template<>
+  class To_Ruby<std::monostate&>
+  {
+  public:
+    static VALUE convert(const std::monostate& data, bool takeOwnership = false)
+    {
+      return Qnil;
+    }
+  };
+
+  template<>
+  class From_Ruby<std::monostate>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      return value == Qnil ? Convertible::Exact : Convertible::None;
+    }
+
+    std::monostate convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return std::monostate();
+      }
+      else
+      {
+        throw std::runtime_error("Can only convert nil values to std::monostate");
+      }
+    }
+  };
+
+  template<>
+  class From_Ruby<std::monostate&>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      return value == Qnil ? Convertible::Exact : Convertible::None;
+    }
+
+    std::monostate& convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return this->converted_;
+      }
+      else
+      {
+        throw std::runtime_error("Can only convert nil values to std::monostate");
+      }
+    }
+    
+  private:
+    std::monostate converted_ = std::monostate();
+  };
+}
+
+
+// =========   multimap.hpp   =========
+
+#include <map>
+
+namespace Rice
+{
+  template<typename K, typename T>
+  Data_Type<std::multimap<K, T>> define_multimap(std::string name = "");
+}
+
+
+// ---------   multimap.ipp   ---------
+#include <map>
+
+namespace Rice
+{
+  namespace stl
+  {
+    template<typename T>
+    class MultimapHelper
+    {
+      using Key_T = typename T::key_type;
+      using Mapped_T = typename T::mapped_type;
+      using Value_T = typename T::value_type;
+      using Reference_T = typename T::reference;
+      using Size_T = typename T::size_type;
+      using Difference_T = typename T::difference_type;
+      using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+
+    public:
+      MultimapHelper(Data_Type<T> klass) : klass_(klass)
+      {
+        this->register_pair();
+        this->define_constructor();
+        this->define_copyable_methods();
+        this->define_capacity_methods();
+        this->define_access_methods();
+        this->define_comparable_methods();
+        this->define_modify_methods();
+        this->define_enumerable();
+        this->define_to_s();
+      }
+
+    private:
+
+      void register_pair()
+      {
+        define_pair<const Key_T, Mapped_T>();
+      }
+
+      void define_constructor()
+      {
+        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
+        {
+          klass_.define_method("copy", [](T& multimap) -> T
+            {
+              throw std::runtime_error("Cannot copy multimaps with non-copy constructible types");
+              return multimap;
+            });
+        }
+      }
+
+      void define_capacity_methods()
+      {
+        klass_.define_method("empty?", &T::empty)
+          .define_method("max_size", &T::max_size)
+          .define_method("size", &T::size);
+        
+        rb_define_alias(klass_, "count", "size");
+        rb_define_alias(klass_, "length", "size");
+      }
+
+      void define_access_methods()
+      {
+        // Access methods
+        klass_.
+          define_method("[]", [](const 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);
+            }
+
+            return result;
+          })
+          .define_method("include?", [](T& multimap, Key_T& key) -> bool
+          {
+              return multimap.find(key) != multimap.end();
+          })
+          .define_method("keys", [](T& multimap) -> std::vector<Key_T>
+            {
+              std::vector<Key_T> result;
+              std::transform(multimap.begin(), multimap.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.first;
+                });
+
+              return result;
+            })
+          .define_method("values", [](T& multimap) -> std::vector<Mapped_T>
+            {
+              std::vector<Mapped_T> result;
+              std::transform(multimap.begin(), multimap.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.second;
+                });
+
+              return result;
+            });
+
+            rb_define_alias(klass_, "has_key", "include?");
+      }
+
+      // Methods that require Value_T to support operator==
+      void define_comparable_methods()
+      {
+        if constexpr (detail::is_comparable_v<Mapped_T>)
+        {
+          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+            {
+              auto it = std::find_if(multimap.begin(), multimap.end(),
+              [&value](auto& pair)
+                {
+                  return pair.second == value;
+                });
+
+              return it != multimap.end();
+          });
+        }
+        else
+        {
+          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          {
+              return false;
+          });
+        }
+
+        rb_define_alias(klass_, "has_value", "value?");
+      }
+
+      void define_modify_methods()
+      {
+        klass_.define_method("clear", &T::clear)
+          .define_method("delete", [](T& multimap, Key_T& key) -> std::optional<Mapped_T>
+          {
+            auto iter = multimap.find(key);
+
+            if (iter != multimap.end())
+            {
+              Mapped_T result = iter->second;
+              multimap.erase(iter);
+              return result;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("insert", [](T& map, Key_T key, Mapped_T& value) -> Mapped_T
+          {
+            Value_T element{ key, value };
+            map.insert(element);
+            return value;
+          });
+      }
+
+      void define_enumerable()
+      {
+        // Add enumerable support
+        klass_.template define_iterator<typename T::iterator (T::*)()>(&T::begin, &T::end);
+      }
+
+      void define_to_s()
+      {
+        if constexpr (detail::is_ostreamable_v<Key_T> && detail::is_ostreamable_v<Mapped_T>)
+        {
+          klass_.define_method("to_s", [](const T& multimap)
+            {
+              auto iter = multimap.begin();
+
+              std::stringstream stream;
+              stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+              stream << "{";
+
+              for (; iter != multimap.end(); iter++)
+              {
+                if (iter != multimap.begin())
+                {
+                  stream << ", ";
+                }
+                stream << iter->first << " => " << iter->second;
+              }
+
+              stream << "}>";
+              return stream.str();
+            });
+        }
+        else
+        {
+          klass_.define_method("to_s", [](const T& multimap)
+            {
+              return "[Not printable]";
+            });
+        }
+      }
+
+      private:
+        Data_Type<T> klass_;
+    };
+  } // namespace
+
+  template<typename Key, typename T>
+  Data_Type<std::multimap<Key, T>> define_multimap(std::string klassName)
+  {
+    using MultiMap_T = std::multimap<Key, T>;
+    using Data_Type_T = Data_Type<MultiMap_T>;
+
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(MultiMap_T));
+      klassName = detail::rubyClassName(typeName);
+    }
+
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
+    }
+
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<MultiMap_T>>(rb_mStd, id);
+    stl::MultimapHelper helper(result);
+    return result;
+  }
+
+  namespace detail
+  {
+    // Helper method - maybe someday create a C++ Ruby set wrapper
+    template<typename T, typename U>
+    std::multimap<T, U> toMultimap(VALUE rubyHash)
+    {
+      using Function_T = void(*)(VALUE, int(*)(VALUE, VALUE, VALUE), VALUE);
+
+      auto block = [](VALUE key, VALUE value, VALUE user_data) -> int
+      {
+        using Key_T = typename std::multimap<T, U>::key_type;
+        using Mapped_T = typename std::multimap<T, U>::mapped_type;
+        using Value_T = typename std::multimap<T, U>::value_type;
+
+        return cpp_protect([&]
+        {
+          Value_T pair = { From_Ruby<Key_T>().convert(key), From_Ruby<Mapped_T>().convert(value) };
+          std::multimap<T, U>* result = (std::multimap<T, U>*)user_data;
+          result->insert(pair);
+          return ST_CONTINUE;
+        });
+      };
+
+      std::multimap<T, U> result;
+      detail::protect<Function_T>(rb_hash_foreach, rubyHash, block, (VALUE)&result);
+      return result;
+    }
+
+    template<typename Key_T, typename T>
+    struct Type<std::multimap<Key_T, T>>
+    {
+      static bool verify()
+      {
+        Type<Key_T>::verify();
+        Type<Key_T>::verify();
+
+        if (!Data_Type<std::multimap<Key_T, T>>::is_defined())
+        {
+          define_multimap<Key_T, T>();
+        }
+
+        return true;
+      }
+    };
+
+    template<typename T, typename U>
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::multimap<T, U> convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped multimap (hopefully!)
+            return *detail::unwrap<std::multimap<T, U>>(value, Data_Type<std::multimap<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby hash and the multimapped type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              return toMultimap<T, U>(value);
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::multimap");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<typename T, typename U>
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::multimap<T, U>& convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped multimap (hopefully!)
+            return *detail::unwrap<std::multimap<T, U>>(value, Data_Type<std::multimap<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the multimap type is copyable
+            if constexpr (std::is_default_constructible_v<std::multimap<T, U>>)
+            {
+              this->converted_ = toMultimap<T, U>(value);
+              return this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::multimap");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+      std::multimap<T, U> converted_;
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::multimap<T, U>*>
+    {
+    public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::multimap<T, U>* convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped multimap (hopefully!)
+            return detail::unwrap<std::multimap<T, U>>(value, Data_Type<std::multimap<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the multimap type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              this->converted_ = toMultimap<T, U>(value);
+              return &this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::multimap");
+          }
+        }
+      }
+
+    private:
+      std::multimap<T, U> converted_;
+    };
+  }
+}
+
+// =========   set.hpp   =========
+
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::set<T>> define_set(std::string klassName = "");
+}
+
+
+// ---------   set.ipp   ---------
+#include <set>
+
+namespace Rice
+{
+  namespace stl
   {
-    static bool verify()
+    template<typename T>
+    class SetHelper
     {
-      return Type<T>::verify();
-    }
-  };
+      // We do NOT use Reference_T and instead use Parameter_T to avoid the weirdness
+      // of std::set<bool>. Reference_T is actually a proxy class that we do not
+      // want to have to register with Rice nor do we want to pass it around.
+      using Key_T = typename T::key_type;
+      using Value_T = typename T::value_type;
+      using Size_T = typename T::size_type;
+      using Difference_T = typename T::difference_type;
+      // For To_Ruby_T however we do need to use reference type because this is what
+      // will be passed by an interator to To_Ruby#convert
+      using Reference_T = typename T::reference;
+      using Parameter_T = std::conditional_t<std::is_pointer_v<Value_T>, Value_T, Value_T&>;
+      using To_Ruby_T = detail::remove_cv_recursive_t<typename T::reference>;
 
-  // ----- shared_ptr -------------
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>>
+    public:
+      SetHelper(Data_Type<T> klass) : klass_(klass)
+      {
+        this->define_constructors();
+        this->define_capacity_methods();
+        this->define_comparable_methods();
+        this->define_modify_methods();
+        this->define_operators();
+        this->define_enumerable();
+        this->define_to_array();
+        this->define_to_s();
+      }
+
+    private:
+
+      void define_constructors()
+      {
+        klass_.define_constructor(Constructor<T>())
+              .define_constructor(Constructor<T, const T&>());
+      }
+
+      void define_capacity_methods()
+      {
+        klass_.define_method("empty?", &T::empty)
+          .define_method("max_size", &T::max_size)
+          .define_method("size", &T::size);
+        
+        rb_define_alias(klass_, "count", "size");
+        rb_define_alias(klass_, "length", "size");
+      }
+
+      void define_comparable_methods()
+      {
+        klass_
+          .define_method("include?", [](T& self, const Key_T element) -> bool
+          {
+            auto iter = self.find(element);
+            return iter != self.end();
+          })
+          .define_method("count", [](T& self, const Key_T element) -> Size_T
+          {
+            return self.count(element);
+          });
+      }
+
+      void define_modify_methods()
+      {
+        klass_
+          .define_method("clear", &T::clear)
+          .define_method("delete", [](T& self, const Key_T key) -> T&
+          {
+            self.erase(key);
+            return self;
+          })
+          .define_method("insert", [](T& self, const Value_T value) -> T&
+          {
+            self.insert(value);
+            return self;
+          })
+          .define_method("merge", [](T& self, T& other) -> T&
+          {
+            self.merge(other);
+            return self;
+          });
+
+        rb_define_alias(klass_, "erase", "delete");
+      }
+
+      void define_operators()
+      {
+        klass_
+          .define_method("<<", [](T& self, const Value_T value) -> T&
+          {
+            self.insert(value);
+            return self;
+          })
+          .define_method("==", [](const T& self, const T& other) -> bool
+          {
+            if constexpr (detail::is_comparable_v<Value_T>)
+            {
+              return self == other;
+            }
+            else
+            {
+              return false;
+            }
+          })
+          .define_method("&", [](const T& self, const T& other) -> T
+          {
+            T result;
+            std::set_intersection(self.begin(), self.end(),
+                                  other.begin(), other.end(),
+                                  std::inserter(result, result.begin()));
+
+            return result;
+          })
+          .define_method("|", [](const T& self, const T& other) -> T
+          {
+            T result;
+            std::set_union(self.begin(), self.end(),
+                           other.begin(), other.end(),
+                           std::inserter(result, result.begin()));
+
+            return result;
+          })
+          .define_method("-", [](const T& self, const T& other) -> T
+          {
+            T result;
+            std::set_difference(self.begin(), self.end(),
+                                other.begin(), other.end(),
+                                std::inserter(result, result.begin()));
+
+            return result;
+          })
+          .define_method("^", [](const T& self, const T& other) -> T
+          {
+            T result;
+            std::set_symmetric_difference(self.begin(), self.end(),
+                                          other.begin(), other.end(),
+                                          std::inserter(result, result.begin()));
+
+            return result;
+          })
+          .define_method("<", [](const T& self, const T& other) -> bool
+          {
+            return std::includes(other.begin(), other.end(),
+                                 self.begin(), self.end());
+          })
+          .define_method(">", [](const T& self, const T& other) -> bool
+          {
+            return std::includes(self.begin(), self.end(),
+                                 other.begin(), other.end());
+          });
+        
+          rb_define_alias(klass_, "eql?", "==");
+          rb_define_alias(klass_, "intersection", "&");
+          rb_define_alias(klass_, "union", "|");
+          rb_define_alias(klass_, "difference", "-");
+          rb_define_alias(klass_, "proper_subset?", "<");
+          rb_define_alias(klass_, "subset?", "<");
+          rb_define_alias(klass_, "proper_superset?", ">");
+          rb_define_alias(klass_, "superset?", ">");
+      }
+
+      void define_enumerable()
+      {
+        // Add enumerable support
+        klass_.template define_iterator<typename T::iterator(T::*)() const>(&T::begin, &T::end);
+      }
+
+      void define_to_array()
+      {
+        // Add enumerable support
+        klass_.define_method("to_a", [](T& self) -> VALUE
+        {
+          Array array;
+          for (const Value_T& element: self)
+          {
+            array.push(element);
+          }
+
+          return array.value();
+        }, Return().setValue());
+      }
+
+      void define_to_s()
+      {
+        if constexpr (detail::is_ostreamable_v<Value_T>)
+        {
+          klass_.define_method("to_s", [](const T& self)
+          {
+            auto iter = self.begin();
+            auto finish = self.end();
+
+            std::stringstream stream;
+            stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+            stream << "{";
+
+            for (; iter != finish; iter++)
+            {
+              if (iter == self.begin())
+              {
+                stream << *iter;
+              }
+              else
+              {
+                stream << ", " << *iter;
+              }
+            }
+
+            stream << "}>";
+            return stream.str();
+          });
+        }
+        else
+        {
+          klass_.define_method("to_s", [](const T& self)
+            {
+              return "[Not printable]";
+            });
+        }
+      }
+
+      private:
+        Data_Type<T> klass_;
+    };
+  } // namespace
+
+  template<typename T>
+  Data_Type<std::set<T>> define_set(std::string klassName)
   {
-  public:
-    VALUE convert(std::shared_ptr<T>& data)
+    using Set_T = std::set<T>;
+    using Data_Type_T = Data_Type<Set_T>;
+
+    if (klassName.empty())
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
+      std::string typeName = detail::typeName(typeid(Set_T));
+      klassName = detail::rubyClassName(typeName);
+    }
 
-      // Use custom wrapper type 
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      return detail::wrap<std::shared_ptr<T>, Wrapper_T>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
     }
-  };
 
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>>
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<Set_T>>(rb_mStd, id);
+    stl::SetHelper helper(result);
+    return result;
+  }
+
+  namespace detail
   {
-  public:
-    From_Ruby() = default;
+    // Helper method - maybe someday create a C++ Ruby set wrapper
+    template<typename T>
+    std::set<T> toSet(VALUE rubySet)
+    {
+      using Function_T = VALUE(*)(VALUE, ID, int, const VALUE*, rb_block_call_func_t, VALUE);
+      static Identifier identifier("each");
+
+      std::set<T> result;
+      auto block = [&result](const typename std::set<T>::value_type element) -> VALUE
+      {
+        result.insert(element);
+        return Qnil;
+      };
+      
+      using NativeFunction_T = NativeFunction<void, decltype(block), false>;
+
+      // 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);
+      
+      return result;
+    }
+
+    template<typename T>
+    struct Type<std::set<T>>
+    {
+      static bool verify()
+      {
+        Type<intrinsic_type<T>>::verify();
+
+        if (!Data_Type<std::set<T>>::is_defined())
+        {
+          define_set<T>();
+        }
+
+        return true;
+      }
+    };
+
+    template<typename T>
+    class From_Ruby<std::set<T>>
+    {
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::set<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              return Convertible::Cast;
+            }
+          }
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::set<T> convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped self (hopefully!)
+            return *detail::unwrap<std::set<T>>(value, Data_Type<std::set<T>>::ruby_data_type(), false);
+          }
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              return toSet<T>(value);
+            }
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<typename T>
+    class From_Ruby<std::set<T>&>
+    {
+    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))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::set<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              return Convertible::Cast;
+            }
+          }
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::set<T>& convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped self (hopefully!)
+            return *detail::unwrap<std::set<T>>(value, Data_Type<std::set<T>>::ruby_data_type(), false);
+          }
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              // If this an Ruby array and the vector type is copyable
+              if constexpr (std::is_default_constructible_v<T>)
+              {
+                this->converted_ = toSet<T>(value);
+                return this->converted_;
+              }
+            }
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+        }
+      }
 
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
+    private:
+      Arg* arg_ = nullptr;
+      std::set<T> converted_;
+    };
 
-    std::shared_ptr<T> convert(VALUE value)
+    template<typename T>
+    class From_Ruby<std::set<T>*>
     {
-      if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
-        return this->arg_->template defaultValue<std::shared_ptr<T>>();
+    private:
+      static inline std::string setName = "Set";
+    public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::set<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              return Convertible::Cast;
+            }
+          }
+          default:
+            return Convertible::None;
+        }
       }
 
-      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
+      std::set<T>* convert(VALUE value)
       {
-        std::string message = "Invalid smart pointer wrapper";
-          throw std::runtime_error(message.c_str());
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped self (hopefully!)
+            return detail::unwrap<std::set<T>>(value, Data_Type<std::set<T>>::ruby_data_type(), false);
+          }
+          case RUBY_T_OBJECT:
+          {
+            Object object(value);
+            if (object.class_name().str() == setName)
+            {
+              // If this an Ruby array and the vector type is copyable
+              if constexpr (std::is_default_constructible_v<T>)
+              {
+                this->converted_ = toSet<T>(value);
+                return &this->converted_;
+              }
+            }
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::set");
+          }
+        }
       }
-      return smartWrapper->data();
-    }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+    private:
+      std::set<T> converted_;
+    };
+  }
+}
 
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    VALUE convert(std::shared_ptr<T>& data)
-    {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
 
-      // Use custom wrapper type 
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      return detail::wrap<std::shared_ptr<T>, Wrapper_T>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
-    }
-  };
+// =========   shared_ptr.hpp   =========
 
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>&>
+namespace Rice::detail
+{
+  template<typename T>
+  class Wrapper<std::shared_ptr<T>> : public WrapperBase
   {
   public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
+    Wrapper(const std::shared_ptr<T>& data);
+    ~Wrapper();
+    void* get() override;
+    std::shared_ptr<T>& data();
 
-    std::shared_ptr<T>& convert(VALUE value)
-    {
-      if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
-        return this->arg_->template defaultValue<std::shared_ptr<T>>();
-      }
+  private:
+    std::shared_ptr<T> data_;
+  };
+}
 
-      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
+}
 
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
-      {
-        std::string message = "Invalid smart pointer wrapper";
-          throw std::runtime_error(message.c_str());
-      }
-      return smartWrapper->data();
-    }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+// ---------   shared_ptr.ipp   ---------
+#include <memory>
 
+// --------- Enable creation of std::shared_ptr from Ruby ---------
+namespace Rice
+{
   template<typename T>
-  struct Type<std::shared_ptr<T>>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName)
   {
-    static bool verify()
+    using SharedPtr_T = std::shared_ptr<T>;
+    using Data_Type_T = Data_Type<SharedPtr_T>;
+
+    if (klassName.empty())
     {
-      return Type<T>::verify();
+      std::string typeName = detail::typeName(typeid(SharedPtr_T));
+      klassName = detail::rubyClassName(typeName);
     }
-  };
-}
 
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
+    }
 
-// =========   monostate.hpp   =========
-
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<SharedPtr_T>>(rb_mStd, id).
+      define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
 
-// ---------   monostate.ipp   ---------
-#include <variant>
+    return result;
+  }
+}
 
+// --------- Wrapper ---------
 namespace Rice::detail
 {
-  template<>
-  struct Type<std::monostate>
+  template<typename T>
+  inline Wrapper<std::shared_ptr<T>>::Wrapper(const std::shared_ptr<T>& data)
+    : data_(data)
   {
-    constexpr static bool verify()
-    {
-      return true;
-    }
-  };
+  }
 
-  template<>
-  class To_Ruby<std::monostate>
+  template<typename T>
+  inline Wrapper<std::shared_ptr<T>>::~Wrapper()
   {
-  public:
-    VALUE convert(const std::monostate& _)
-    {
-      return Qnil;
-    }
-  };
+    Registries::instance.instances.remove(this->get());
+  }
 
-  template<>
-  class To_Ruby<std::monostate&>
+  template<typename T>
+  inline void* Wrapper<std::shared_ptr<T>>::get()
   {
-  public:
-    static VALUE convert(const std::monostate& data, bool takeOwnership = false)
+    return (void*)this->data_.get();
+  }
+
+  template<typename T>
+  inline std::shared_ptr<T>& Wrapper<std::shared_ptr<T>>::data()
+  {
+    return data_;
+  }
+}
+
+// --------- Type/To_Ruby/From_Ruby ---------
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::shared_ptr<T>>
+  {
+    static bool verify()
     {
-      return Qnil;
+      return Type<T>::verify();
     }
   };
 
-  template<>
-  class From_Ruby<std::monostate>
+  template <typename T>
+  class To_Ruby<std::shared_ptr<T>>
   {
   public:
-    bool is_convertible(VALUE value)
+    VALUE convert(std::shared_ptr<T>& data)
     {
-      return false;
+      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);
+      }
     }
 
-    std::monostate convert(VALUE value)
+    VALUE convert(std::shared_ptr<T>&& data)
     {
-      return std::monostate();
+      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);
+      }
     }
   };
 
-  template<>
-  class From_Ruby<std::monostate&>
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>>
   {
   public:
-    bool is_convertible(VALUE value)
-    {
-      return false;
-    }
+    From_Ruby() = default;
 
-    std::monostate& convert(VALUE value)
+    explicit From_Ruby(Arg * arg) : arg_(arg)
     {
-      return this->converted_;
     }
-    
-  private:
-    std::monostate converted_ = std::monostate();
-  };
-}
-
-
-// =========   variant.hpp   =========
-
-
-// ---------   variant.ipp   ---------
-#include <variant>
-
-namespace Rice::detail
-{
-  template<typename...Types>
-  struct Type<std::variant<Types...>>
-  {
-    using Tuple_T = std::tuple<Types...>;
 
-    template<std::size_t... I>
-    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    Convertible is_convertible(VALUE value)
     {
-      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
-    template<std::size_t... I>
-    constexpr static bool verify()
+    std::shared_ptr<T> convert(VALUE value)
     {
-      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return verifyTypes(indices);
+      // Get the wrapper
+      WrapperBase* wrapperBase = detail::getWrapper(value);
+
+      // Was this shared_ptr created by the user from Ruby? If so it will
+      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
+      // return the shared pointer
+      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
+      {
+        // Use unwrap to validate the underlying wrapper is the correct type
+        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>)
+      {
+        // 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());
+        return wrapper->data();
+      }
+      else
+      {
+        // 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());
+        return wrapper->data();
+      }
     }
+  private:
+    Arg* arg_ = nullptr;
   };
 
-  template<typename...Types>
-  class To_Ruby<std::variant<Types...>>
+  template <typename T>
+  class To_Ruby<std::shared_ptr<T>&>
   {
   public:
-
-    template<typename T>
-    static VALUE convertElement(const std::variant<Types...>& data, bool takeOwnership)
+    VALUE convert(std::shared_ptr<T>& data)
     {
-      return To_Ruby<T>().convert(std::get<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);
+      }
     }
+  };
 
-    template<std::size_t... I>
-    static VALUE convertIterator(const std::variant<Types...>& 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...>;
-      
-      /* This is a fold expression. In pseudo code:
-       
-        for (type in variant.types)
-        {
-          if (variant.has_value<type>())
-            return ToRuby<type>().convert(variant.getValue<type>)
-        }
-
-        The list of variant types is stored in Tuple_T. The number of types is stored in I.
-        Starting with index 0, get the variant type using td::tuple_element_t<I, Tuple_T>>.
-        Next check if the variant has a value for that type using std::holds_alternative<T>. 
-        If yes, then call convertElement and save the return value to result. Then use the 
-        comma operator to return true to the fold expression. If the variant does not have
-        a value for the type then return false. 
-        
-        The fold operator is or (||). If an index returns false, then the next index is evaulated
-        up until I. 
-        
-        Code inspired by https://www.foonathan.net/2020/05/fold-tricks/ */
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>&>
+  {
+  public:
+    From_Ruby() = default;
 
-      VALUE result = Qnil;
-      ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
-               (result = convertElement<std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
 
-      return result;
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
-    static VALUE convert(const std::variant<Types...>& data, bool takeOwnership = false)
+    std::shared_ptr<T>& convert(VALUE value)
     {
-      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      // Get the wrapper
+      WrapperBase* wrapperBase = detail::getWrapper(value);
+
+      // Was this shared_ptr created by the user from Ruby? If so it will
+      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
+      // return the shared pointer
+      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
+      {
+        // Use unwrap to validate the underlying wrapper is the correct type
+        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>)
+      {
+        // 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());
+        return wrapper->data();
+      }
+      else
+      {
+        // 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());
+        return wrapper->data();
+      }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
+}
+
 
+// =========   tuple.hpp   =========
+
+
+// ---------   tuple.ipp   ---------
+#include <tuple>
+
+namespace Rice::detail
+{
   template<typename...Types>
-  class To_Ruby<std::variant<Types...>&>
+  struct Type<std::tuple<Types...>>
   {
-  public:
-    template<typename T>
-    static VALUE convertElement(const std::variant<Types...>& data, bool takeOwnership)
-    {
-      return To_Ruby<T>().convert(std::get<T>(data));
-    }
+    using Tuple_T = std::tuple<Types...>;
 
     template<std::size_t... I>
-    static VALUE convertIterator(const std::variant<Types...>& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    constexpr static bool verifyTypes(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...>;
-
-      // See comments above for explanation of this code
-      VALUE result = Qnil;
-      ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
-        (result = convertElement<std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
-
-      return result;
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
 
-    static VALUE convert(const std::variant<Types...>& data, bool takeOwnership = false)
+    template<std::size_t... I>
+    constexpr static bool verify()
     {
-      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      auto indices = std::make_index_sequence<std::tuple_size_v<std::tuple<Types...>>>{};
+      return verifyTypes(indices);
     }
   };
 
   template<typename...Types>
-  class From_Ruby<std::variant<Types...>>
+  class To_Ruby<std::tuple<Types...>>
   {
-  private:
-    // Possible converters we could use for this variant
-    using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
-
   public:
-    /* This method loops over each type in the variant, creates a From_Ruby converter,
-       and then check if the converter can work with the provided Rby value (it checks
-       the type of the Ruby object to see if it matches the variant type). 
-       If yes, then the converter runs. If no, then the method recursively calls itself
-       increasing the index. 
-       
-       We use recursion, with a constexpr, to avoid having to instantiate an instance
-       of the variant to store results from a fold expression like the To_Ruby code
-       does above. That allows us to process variants with non default constructible
-       arguments like std::reference_wrapper. */
-    template <std::size_t I = 0>
-    std::variant<Types...> convertInternal(VALUE value)
+    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
     {
-      // Loop over each possible type in the variant.
-      if constexpr (I < std::variant_size_v<std::variant<Types...>>)
-      {
-        // Get the converter for the current index
-        typename std::tuple_element_t<I, From_Ruby_Ts> converter;
+      Array result;
 
-        // See if it will work
-        if (converter.is_convertible(value))
-        {
-          return converter.convert(value);
-        }
-        else
-        {
-          return convertInternal<I + 1>(value);
-        }
-      }
-      throw std::runtime_error("Could not find converter for variant");
-    }
+      for_each_tuple(data, [&](auto element)
+      {
+        using Element_T = decltype(element);
+        result.push<Element_T>((Element_T)element);
+      });
 
-    std::variant<Types...> convert(VALUE value)
-    {
-      return convertInternal(value);
+      return result.value();
     }
   };
 
   template<typename...Types>
-  class From_Ruby<std::variant<Types...>&>
+  class To_Ruby<std::tuple<Types...>&>
   {
-  private:
-    // Possible converters we could use for this variant
-    using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
-
   public:
-    template <std::size_t I = 0>
-    std::variant<Types...> convertInternal(VALUE value)
+    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
     {
-      // Loop over each possible type in the variant
-      if constexpr (I < std::variant_size_v<std::variant<Types...>>)
-      {
-        // Get the converter for the current index
-        typename std::tuple_element_t<I, From_Ruby_Ts> converter;
+      Array result;
 
-        // See if it will work
-        if (converter.is_convertible(value))
-        {
-          return converter.convert(value);
-        }
-        else
+      for_each_tuple(data, [&](auto& value)
         {
-          return convertInternal<I + 1>(value);
-        }
-      }
-      throw std::runtime_error("Could not find converter for variant");
-    }
+          VALUE element = detail::To_Ruby<decltype(value)>().convert(value);
+          result.push(element);
+        });
 
-    std::variant<Types...> convert(VALUE value)
-    {
-      return convertInternal(value);
+      return result.value();
     }
   };
-}
-
-
-// =========   pair.hpp   =========
-
-
-namespace Rice
-{
-  template<typename T>
-  Data_Type<T> define_pair(std::string name);
-
-  template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name);
-}
-
-
-// ---------   pair.ipp   ---------
-
-#include <sstream>
-#include <stdexcept>
-#include <utility>
 
-namespace Rice
-{
-  namespace stl
+  template<typename...Types>
+  class From_Ruby<std::tuple<Types...>>
   {
-    template<typename T>
-    class PairHelper
-    {
-    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_to_s();
-      }
+  public:
+    using Tuple_T = std::tuple<Types...>;
 
-    private:
-      void define_constructor()
-      {
-        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
-      }
+    template<std::size_t... I>
+    constexpr static bool verifyTypes(Array& array, std::index_sequence<I...>& indices)
+    {
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+    }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
-        {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              return pair;
-            });
-        }
-        else
-        {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              throw std::runtime_error("Cannot copy pair with non-copy constructible types");
-              return pair;
-            });
-        }
-      }
+    Convertible is_convertible(VALUE value)
+    {
+      Convertible result = Convertible::None;
 
-      void define_access_methods()
+      // The ruby value must be an array of the correct size
+      if (rb_type(value) != RUBY_T_ARRAY || Array(value).size() != std::tuple_size_v<Tuple_T>)
       {
-        // 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;
-          });
+        return result;
       }
-
-      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::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&
+      
+      // Now check that each tuple type is convertible
+      Array array(value);
+      int i = 0;
+      for_each_tuple(this->fromRubys_,
+        [&](auto& fromRuby)
         {
-          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;
-          }
+          result = result | fromRuby.is_convertible(array[i].value());
+          i++;
         });
-      }
 
-      void define_to_s()
-      {
-        if constexpr (detail::is_ostreamable_v<typename T::first_type> && detail::is_ostreamable_v<typename T::second_type>)
-        {
-          klass_.define_method("to_s", [](const T& pair)
-            {
-              std::stringstream stream;
-              stream << "[" << pair.first << ", " << pair.second << "]";
-              return stream.str();
-            });
-        }
-        else
-        {
-          klass_.define_method("to_s", [](const T& pair)
-            {
-              return "[Not printable]";
-            });
-        }
-      }
+      return result;
+    }
 
-      private:
-        Data_Type<T> klass_;
-    };
-  } // namespace
+    template <std::size_t... I>
+    std::tuple<Types...> convertInternal(Array array, std::index_sequence<I...>& indices)
+    {
+      return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(array[I].value())...);
+    }
 
-  template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name)
-  {
-    if (detail::Registries::instance.types.isDefined<T>())
+    std::tuple<Types...> convert(VALUE value)
     {
-      // If the pair has been previously seen it will be registered but may
-      // not be associated with the constant Module::<name>
-      module.const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      Array array(value);
+      auto indices = std::make_index_sequence<std::tuple_size_v<Tuple_T>>{};
+      return convertInternal(array, indices);
     }
 
-    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
-    stl::PairHelper helper(result);
-    return result;
-  }
+  private:
+    // Possible converters we could use for this variant
+    using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
+    From_Ruby_Ts fromRubys_;
+  };
 
-  template<typename T>
-  Data_Type<T> define_pair(std::string name)
+/*  template<typename...Types>
+  class From_Ruby<std::tuple<Types...>&> : public From_Ruby<std::tuple<Types...>>
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+  public:
+    std::tuple<Types...>& convert(VALUE value)
     {
-      // If the pair has been previously seen it will be registered but may
-      // not be associated with the constant Object::<name>
-      Object(rb_cObject).const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      int index = this->figureIndex(value);
+      this->converted_ = this->convertInternal(value, index);
+      return this->converted_;
     }
 
-    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
-    stl::PairHelper<T> helper(result);
-    return result;
-  }
+  private:
+    std::tuple<Types...> converted_;
+  };*/
+}
 
-  template<typename T>
-  Data_Type<T> define_pair_auto()
+
+// =========   type_index.hpp   =========
+
+
+// ---------   type_index.ipp   ---------
+#include <typeindex>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::type_index> define_type_index()
   {
-    std::string klassName = detail::makeClassName(typeid(T));
-    Module rb_mRice = define_module("Rice");
-    Module rb_mpair = define_module_under(rb_mRice, "Std");
-    return define_pair_under<T>(rb_mpair, klassName);
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::type_index>(rb_mStd, "TypeIndex").
+      define_constructor(Constructor<std::type_index, const std::type_info&>()).
+      define_method("hash_code", &std::type_index::hash_code).
+      define_method("name", &std::type_index::name);
   }
-   
-  namespace detail
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::type_index>
   {
-    template<typename T1, typename T2>
-    struct Type<std::pair<T1, T2>>
+    static bool verify()
     {
-      static bool verify()
+      if (!detail::Registries::instance.types.isDefined<std::type_index>())
       {
-        detail::verifyType<T1>();
-        detail::verifyType<T2>();
-
-        if (!detail::Registries::instance.types.isDefined<std::pair<T1, T2>>())
-        {
-          define_pair_auto<std::pair<T1, T2>>();
-        }
-
-        return true;
+        stl::define_type_index();
       }
-    };
-  }
+
+      return true;
+    }
+  };
 }
 
 
+// =========   type_info.hpp   =========
 
-// =========   map.hpp   =========
 
+// ---------   type_info.ipp   ---------
+#include <typeinfo>
 
-namespace Rice
+namespace Rice::stl
 {
-  template<typename U>
-  Data_Type<U> define_map(std::string name);
+  inline Data_Type<std::type_info> define_type_info()
+  {
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::type_info>(rb_mStd, "TypeInfo").
+      define_method("hash_code", &std::type_info::hash_code).
+      define_method("name", &std::type_info::name);
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::type_info>
+  {
+    static inline bool verify()
+    {
+      if (!detail::Registries::instance.types.isDefined<std::type_info>())
+      {
+        stl::define_type_info();
+      }
 
-  template<typename U>
-  Data_Type<U> define_map_under(Object module, std::string name);
+      return true;
+    }
+  };
 }
 
 
-// ---------   map.ipp   ---------
+// =========   variant.hpp   =========
 
-#include <sstream>
-#include <stdexcept>
-#include <map>
-#include <type_traits>
+
+// ---------   variant.ipp   ---------
 #include <variant>
 
-namespace Rice
+namespace Rice::detail
 {
-  namespace stl
+  template<typename...Types>
+  struct Type<std::variant<Types...>>
   {
-    template<typename T>
-    class MapHelper
-    {
-      using Key_T = typename T::key_type;
-      using Mapped_T = typename T::mapped_type;
-      using Value_T = typename T::value_type;
-      using Size_T = typename T::size_type;
-      using Difference_T = typename T::difference_type;
+    using Tuple_T = std::tuple<Types...>;
 
-    public:
-      MapHelper(Data_Type<T> klass) : klass_(klass)
-      {
-        this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
-        this->define_capacity_methods();
-        this->define_access_methods();
-        this->define_comparable_methods();
-        this->define_modify_methods();
-        this->define_enumerable();
-        this->define_to_s();
-        this->define_to_hash();
-      }
+    template<std::size_t... I>
+    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    {
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+    }
 
-    private:
+    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);
+    }
+  };
 
-      void register_pair()
-      {
-        define_pair_auto<Value_T>();
-      }
+  template<typename...Types>
+  class To_Ruby<std::variant<Types...>>
+  {
+  public:
 
-      void define_constructor()
-      {
-        klass_.define_constructor(Constructor<T>());
-      }
+    template<typename U, typename V>
+    static VALUE convertElement(U& data, bool takeOwnership)
+    {
+      return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+    }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
-        {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              return map;
-            });
-        }
-        else
+    template<typename U, std::size_t... I>
+    static 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...>;
+      
+      /* This is a fold expression. In pseudo code:
+       
+        for (type in variant.types)
         {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              throw std::runtime_error("Cannot copy maps with non-copy constructible types");
-              return map;
-            });
+          if (variant.has_value<type>())
+            return ToRuby<type>().convert(variant.getValue<type>)
         }
-      }
 
-      void define_capacity_methods()
-      {
-        klass_.define_method("empty?", &T::empty)
-          .define_method("max_size", &T::max_size)
-          .define_method("size", &T::size);
+        The list of variant types is stored in Tuple_T. The number of types is stored in I.
+        Starting with index 0, get the variant type using td::tuple_element_t<I, Tuple_T>>.
+        Next check if the variant has a value for that type using std::holds_alternative<T>. 
+        If yes, then call convertElement and save the return value to result. Then use the 
+        comma operator to return true to the fold expression. If the variant does not have
+        a value for the type then return false. 
         
-        rb_define_alias(klass_, "count", "size");
-        rb_define_alias(klass_, "length", "size");
-      }
+        The fold operator is or (||). If an index returns false, then the next index is evaluated
+        up until I. 
+        
+        Code inspired by https://www.foonathan.net/2020/05/fold-tricks/ */
 
-      void define_access_methods()
-      {
-        // Access methods
-        klass_.define_method("[]", [](const T& map, const Key_T& key) -> std::optional<Mapped_T>
-          {
-            auto iter = map.find(key);
+      VALUE result = Qnil;
 
-            if (iter != map.end())
-            {
-              return iter->second;
-            }
-            else
-            {
-              return std::nullopt;
-            }
-          })
-          .define_method("include?", [](T& map, Key_T& key) -> bool
-          {
-              return map.find(key) != map.end();
-          })
-          .define_method("keys", [](T& map) -> std::vector<Key_T>
-            {
-              std::vector<Key_T> result;
-              std::transform(map.begin(), map.end(), std::back_inserter(result),
-                [](const auto& pair)
-                {
-                  return pair.first;
-                });
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wunused-value"
+      #endif
 
-              return result;
-            })
-          .define_method("values", [](T& map) -> std::vector<Mapped_T>
-            {
-              std::vector<Mapped_T> result;
-              std::transform(map.begin(), map.end(), std::back_inserter(result),
-                [](const auto& pair)
-                {
-                  return pair.second;
-                });
+      ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
+               (result = convertElement<U, std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
+      
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic pop
+      #endif
 
-              return result;
-            });
+      return result;
+    }
 
-            rb_define_alias(klass_, "has_key", "include?");
-      }
+    template<typename U>
+    static VALUE convert(U& data, bool takeOwnership = false)
+    {
+      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
+      return convertIterator(data, takeOwnership, indices);
+    }
 
-      // Methods that require Value_T to support operator==
-      void define_comparable_methods()
+    template<typename U>
+    static VALUE convert(U&& data, bool takeOwnership = false)
+    {
+      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
+      return convertIterator(data, takeOwnership, indices);
+    }
+  };
+
+  template<typename...Types>
+  class To_Ruby<std::variant<Types...>&>
+  {
+  public:
+    template<typename U, typename V>
+    static VALUE convertElement(U& data, bool takeOwnership)
+    {
+      if constexpr (std::is_const_v<U>)
       {
-        if constexpr (detail::is_comparable_v<Mapped_T>)
-        {
-          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
-            {
-              auto it = std::find_if(map.begin(), map.end(),
-              [&value](auto& pair)
-                {
-                  return pair.second == value;
-                });
+        return To_Ruby<V>().convert(std::get<V>(data));
+      }
+      else
+      {
+        return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+      }
+    }
 
-              return it != map.end();
-          });
-        }
-        else
-        {
-          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
-          {
-              return false;
-          });
-        }
+    template<typename U, std::size_t... I>
+    static 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...>;
 
-        rb_define_alias(klass_, "has_value", "value?");
-      }
+      // See comments above for explanation of this code
+      VALUE result = Qnil;
 
-      void define_modify_methods()
-      {
-        klass_.define_method("clear", &T::clear)
-          .define_method("delete", [](T& map, Key_T& key) -> std::optional<Mapped_T>
-            {
-              auto iter = map.find(key);
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wunused-value"
+      #endif
 
-              if (iter != map.end())
-              {
-                Mapped_T result = iter->second;
-                map.erase(iter);
-                return result;
-              }
-              else
-              {
-                return std::nullopt;
-              }
-            })
-          .define_method("[]=", [](T& map, Key_T key, Mapped_T value) -> Mapped_T
-            {
-              map[key] = value;
-              return value;
-            });
+      ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
+        (result = convertElement<U, std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
+
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic pop
+      #endif
+
+      return result;
+    }
+
+    template<typename U>
+    static VALUE convert(U& data, bool takeOwnership = false)
+    {
+      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
+      return convertIterator(data, takeOwnership, indices);
+    }
+  };
 
-          rb_define_alias(klass_, "store", "[]=");
-      }
+  template<typename...Types>
+  class From_Ruby<std::variant<Types...>>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      Convertible result = Convertible::None;
 
-      void define_enumerable()
-      {
-        // Add enumerable support
-        klass_.template define_iterator<typename T::iterator (T::*)()>(&T::begin, &T::end);
-      }
+      for_each_tuple(this->fromRubys_,
+        [&](auto& fromRuby)
+        {
+          result = result | fromRuby.is_convertible(value);
+        });
 
-      void define_to_hash()
-      {
-        // Add enumerable support
-        klass_.define_method("to_h", [](T& map)
+      return result;
+    }
+
+    // This method search through a variant's types to figure out which one the
+    // currently Ruby value best matches. It then returns the index of the type.
+    int figureIndex(VALUE value)
+    {
+      int i = 0;
+      int index = -1;
+      Convertible foundConversion = Convertible::None;
+
+      for_each_tuple(this->fromRubys_,
+        [&](auto& fromRuby)
         {
-          VALUE result = rb_hash_new();
-          std::for_each(map.begin(), map.end(), [&result](const typename T::reference pair)
-          {
-            VALUE key = detail::To_Ruby<Key_T&>().convert(pair.first);
-            VALUE value = detail::To_Ruby<Mapped_T&>().convert(pair.second);
-            rb_hash_aset(result, key, value);
-          });
+          Convertible isConvertible = fromRuby.is_convertible(value);
 
-          return result;
-        }, Return().setValue());
-      }
+          if (isConvertible > foundConversion)
+          {
+            index = i;
+            foundConversion = isConvertible;
+          }
+          i++;
+        });
 
-      void define_to_s()
+      if (index == -1)
       {
-        if constexpr (detail::is_ostreamable_v<Key_T> && detail::is_ostreamable_v<Mapped_T>)
-        {
-          klass_.define_method("to_s", [](const T& map)
-            {
-              auto iter = map.begin();
+        rb_raise(rb_eArgError, "Could not find converter for variant");
+      }
 
-              std::stringstream stream;
-              stream << "{";
+      return index;
+    }
 
-              for (; iter != map.end(); iter++)
-              {
-                if (iter != map.begin())
-                {
-                  stream << ", ";
-                }
-                stream << iter->first << " => " << iter->second;
-              }
+    /* This method loops over each type in the variant, creates a From_Ruby converter,
+       and then check if the converter can work with the provided Rby value (it checks
+       the type of the Ruby object to see if it matches the variant type).
+       If yes, then the converter runs. If no, then the method recursively calls itself
+       increasing the index.
 
-              stream << "}";
-              return stream.str();
-            });
+       We use recursion, with a constexpr, to avoid having to instantiate an instance
+       of the variant to store results from a fold expression like the To_Ruby code
+       does above. That allows us to process variants with non default constructible
+       arguments like std::reference_wrapper. */
+    template <std::size_t I = 0>
+    std::variant<Types...> convertInternal(VALUE value, int index)
+    {
+      if constexpr (I < std::variant_size_v<std::variant<Types...>>)
+      {
+        if (I == index)
+        {
+          auto fromRuby = std::get<I>(this->fromRubys_);
+          return fromRuby.convert(value);
         }
         else
         {
-          klass_.define_method("to_s", [](const T& map)
-            {
-              return "[Not printable]";
-            });
+          return convertInternal<I + 1>(value, index);
         }
       }
+      rb_raise(rb_eArgError, "Could not find converter for variant");
+    }
 
-      private:
-        Data_Type<T> klass_;
-    };
-  } // namespace
-
-  template<typename T>
-  Data_Type<T> define_map_under(Object module, std::string name)
-  {
-    if (detail::Registries::instance.types.isDefined<T>())
+    std::variant<Types...> convert(VALUE value)
     {
-      // If the map has been previously seen it will be registered but may
-      // not be associated with the constant Module::<name>
-      module.const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      int index = this->figureIndex(value);
+      return this->convertInternal(value, index);
     }
 
-    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
-    stl::MapHelper helper(result);
-    return result;
-  }
+  private:
+    // Possible converters we could use for this variant
+    using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
+    From_Ruby_Ts fromRubys_;
+  };
 
-  template<typename T>
-  Data_Type<T> define_map(std::string name)
+  template<typename...Types>
+  class From_Ruby<std::variant<Types...>&> : public From_Ruby<std::variant<Types...>>
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+  public:
+    std::variant<Types...>& convert(VALUE value)
     {
-      // If the map has been previously seen it will be registered but may
-      // not be associated with the constant Object::<name>
-      Object(rb_cObject).const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      int index = this->figureIndex(value);
+      this->converted_ = this->convertInternal(value, index);
+      return this->converted_;
     }
 
-    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
-    stl::MapHelper<T> helper(result);
-    return result;
-  }
+  private:
+    std::variant<Types...> converted_;
+  };
+}
+
 
+// =========   unique_ptr.hpp   =========
+
+namespace Rice::detail
+{
   template<typename T>
-  Data_Type<T> define_map_auto()
-  {
-    std::string klassName = detail::makeClassName(typeid(T));
-    Module rb_mRice = define_module("Rice");
-    Module rb_mmap = define_module_under(rb_mRice, "Std");
-    return define_map_under<T>(rb_mmap, klassName);
-  }
-   
-  namespace detail
+  class Wrapper<std::unique_ptr<T>> : public WrapperBase
   {
-    template<typename T, typename U>
-    struct Type<std::map<T, U>>
-    {
-      static bool verify()
-      {
-        Type<T>::verify();
-        Type<U>::verify();
+  public:
+    Wrapper(std::unique_ptr<T>&& data);
+    ~Wrapper();
+    void* get() override;
+    std::unique_ptr<T>& data();
 
-        if (!detail::Registries::instance.types.isDefined<std::map<T, U>>())
-        {
-          define_map_auto<std::map<T, U>>();
-        }
+  private:
+    std::unique_ptr<T> data_;
+  };
+}
 
-        return true;
-      }
-    };
 
-    template<typename T, typename U>
-    struct MapFromHash
-    {
-      static int convertPair(VALUE key, VALUE value, VALUE user_data)
-      {
-        std::map<T, U>* result = (std::map<T, U>*)(user_data);
+// ---------   unique_ptr.ipp   ---------
+#include <memory>
 
-        // This method is being called from Ruby so we cannot let any C++ 
-        // exceptions propogate back to Ruby
-        return cpp_protect([&]
-        {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
-          return ST_CONTINUE;
-        });
-      }
+namespace Rice::detail
+{
+  template<typename T>
+  inline Wrapper<std::unique_ptr<T>>::Wrapper(std::unique_ptr<T>&& data)
+    : data_(std::move(data))
+  {
+  }
 
-      static std::map<T, U> convert(VALUE value)
-      {
-        std::map<T, U> result;
-        VALUE user_data = (VALUE)(&result);
+  template<typename T>
+  inline Wrapper<std::unique_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+  }
 
-        // MSVC needs help here, but g++ does not
-        using Rb_Hash_ForEach_T = void(*)(VALUE, int(*)(VALUE, VALUE, VALUE), VALUE);
-        detail::protect<Rb_Hash_ForEach_T>(rb_hash_foreach, value, convertPair, user_data);
+  template<typename T>
+  inline void* Wrapper<std::unique_ptr<T>>::get()
+  {
+    return (void*)this->data_.get();
+  }
 
-        return result;
-      }
-    };
+  template<typename T>
+  inline std::unique_ptr<T>& Wrapper<std::unique_ptr<T>>::data()
+  {
+    return data_;
+  }
 
-    template<typename T, typename U>
-    class From_Ruby<std::map<T, U>>
+  template <typename T>
+  class To_Ruby<std::unique_ptr<T>>
+  {
+  public:
+    VALUE convert(std::unique_ptr<T>& data)
     {
-    public:
-      From_Ruby() = default;
+      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);
+    }
 
-      explicit From_Ruby(Arg * arg) : arg_(arg)
-      {
-      }
+    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, data, true);
+    }
+  };
 
-      std::map<T, U> convert(VALUE value)
-      {
-        switch (rb_type(value))
-        {
-          case T_DATA:
-          {
-            // This is a wrapped map (hopefully!)
-            return *Data_Object<std::map<T, U>>::from_ruby(value);
-          }
-          case T_HASH:
-          {
-            // If this an Ruby hash and the mapped type is copyable
-            if constexpr (std::is_default_constructible_v<U>)
-            {
-              return MapFromHash<T, U>::convert(value);
-            }
-          }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::map<T, U>>();
-            }
-          }
-          default:
-          {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
-              detail::protect(rb_obj_classname, value), "std::map");
-          }
-        }
-      }
+  template <typename T>
+  class To_Ruby<std::unique_ptr<T>&>
+  {
+  public:
+    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);
+    }
+  };
 
-    private:
-      Arg* arg_ = nullptr;
-    };
+  template <typename T>
+  class From_Ruby<std::unique_ptr<T>>
+  {
+  public:
+    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    {
+      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+    }
 
-    template<typename T, typename U>
-    class From_Ruby<std::map<T, U>&>
+    Convertible is_convertible(VALUE value)
     {
-    public:
-      From_Ruby() = default;
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
 
-      explicit From_Ruby(Arg * arg) : arg_(arg)
+      switch (rb_type(value))
       {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
       }
+    }
 
-      std::map<T, U>& convert(VALUE value)
+    std::unique_ptr<T> convert(VALUE value)
+    {
+      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
+      if (!wrapper)
       {
-        switch (rb_type(value))
-        {
-          case T_DATA:
-          {
-            // This is a wrapped map (hopefully!)
-            return *Data_Object<std::map<T, U>>::from_ruby(value);
-          }
-          case T_HASH:
-          {
-            // If this an Ruby array and the map type is copyable
-            if constexpr (std::is_default_constructible_v<std::map<T, U>>)
-            {
-              this->converted_ = MapFromHash<T, U>::convert(value);
-              return this->converted_;
-            }
-          }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::map<T, U>>();
-            }
-          }
-          default:
-          {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
-              detail::protect(rb_obj_classname, value), "std::map");
-          }
-        }
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
       }
+      return std::move(wrapper->data());
+    }
+  };
 
-    private:
-      Arg* arg_ = nullptr;
-      std::map<T, U> converted_;
-    };
+  template <typename T>
+  class From_Ruby<std::unique_ptr<T>&>
+  {
+  public:
+    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    {
+      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+    }
 
-    template<typename T, typename U>
-    class From_Ruby<std::map<T, U>*>
+    Convertible is_convertible(VALUE value)
     {
-    public:
-      std::map<T, U>* convert(VALUE value)
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
       {
-        switch (rb_type(value))
-        {
-          case T_DATA:
-          {
-            // This is a wrapped map (hopefully!)
-            return Data_Object<std::map<T, U>>::from_ruby(value);
-          }
-          case T_HASH:
-          {
-            // If this an Ruby array and the map type is copyable
-            if constexpr (std::is_default_constructible_v<U>)
-            {
-              this->converted_ = MapFromHash<T, U>::convert(value);
-              return &this->converted_;
-            }
-          }
-          default:
-          {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
-              detail::protect(rb_obj_classname, value), "std::map");
-          }
-        }
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
       }
+    }
 
-    private:
-      std::map<T, U> converted_;
-    };
-  }
+    std::unique_ptr<T>& convert(VALUE value)
+    {
+      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
+      if (!wrapper)
+      {
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
+      }
+      return wrapper->data();
+    }
+  };
+
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
 }
 
-// =========   unordered_map.hpp   =========
 
+// =========   unordered_map.hpp   =========
 
 namespace Rice
 {
-  template<typename U>
-  Data_Type<U> define_unordered_map(std::string name);
-
-  template<typename U>
-  Data_Type<U> define_unordered_map_under(Object module, std::string name);
+  template<typename Key, typename T>
+  Data_Type<std::unordered_map<Key, T>> define_unordered_map(std::string name = "");
 }
 
 
 // ---------   unordered_map.ipp   ---------
-
-#include <sstream>
-#include <stdexcept>
-#include <type_traits>
 #include <unordered_map>
-#include <variant>
 
 namespace Rice
 {
@@ -1608,8 +3168,10 @@ namespace Rice
       using Key_T = typename T::key_type;
       using Mapped_T = typename T::mapped_type;
       using Value_T = typename T::value_type;
+      using Reference_T = typename T::reference;
       using Size_T = typename T::size_type;
       using Difference_T = typename T::difference_type;
+      using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
 
     public:
       UnorderedMapHelper(Data_Type<T> klass) : klass_(klass)
@@ -1630,7 +3192,7 @@ namespace Rice
 
       void register_pair()
       {
-        define_pair_auto<Value_T>();
+        define_pair<const Key_T, T>();
       }
 
       void define_constructor()
@@ -1758,7 +3320,7 @@ namespace Rice
                 return std::nullopt;
               }
             })
-          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_T value) -> Mapped_T
+          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_T& value) -> Mapped_T
             {
               unordered_map[key] = value;
               return value;
@@ -1779,10 +3341,10 @@ namespace Rice
         klass_.define_method("to_h", [](T& unordered_map)
         {
           VALUE result = rb_hash_new();
-          std::for_each(unordered_map.begin(), unordered_map.end(), [&result](const auto& pair)
+          std::for_each(unordered_map.begin(), unordered_map.end(), [&result](const Reference_T& pair)
           {
-            VALUE key = detail::To_Ruby<Key_T>().convert(pair.first);
-            VALUE value = detail::To_Ruby<Mapped_T>().convert(pair.second);
+            VALUE key = detail::To_Ruby<Key_T&>().convert(pair.first);
+            VALUE value = detail::To_Ruby<To_Ruby_T&>().convert(pair.second);
             rb_hash_aset(result, key, value);
           });
 
@@ -1828,60 +3390,43 @@ namespace Rice
     };
   } // namespace
 
-  template<typename T>
-  Data_Type<T> define_unordered_map_under(Object module, std::string name)
+  template<typename Key, typename T>
+  Data_Type<std::unordered_map<Key, T>> define_unordered_map(std::string klassName)
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+    using UnorderedMap_T = std::unordered_map<Key, T>;
+    using Data_Type_T = Data_Type<UnorderedMap_T>;
+
+    if (klassName.empty())
     {
-      // If the unordered_map has been previously seen it will be registered but may
-      // not be associated with the constant Module::<name>
-      module.const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      std::string typeName = detail::typeName(typeid(UnorderedMap_T));
+      klassName = detail::rubyClassName(typeName);
     }
 
-    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
-    stl::UnorderedMapHelper helper(result);
-    return result;
-  }
-
-  template<typename T>
-  Data_Type<T> define_unordered_map(std::string name)
-  {
-    if (detail::Registries::instance.types.isDefined<T>())
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
     {
-      // If the unordered_map has been previously seen it will be registered but may
-      // not be associated with the constant Object::<name>
-      Object(rb_cObject).const_set_maybe(name, Data_Type<T>().klass());
-      return Data_Type<T>();
+      return Data_Type_T();
     }
 
-    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
-    stl::UnorderedMapHelper<T> helper(result);
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<UnorderedMap_T>>(rb_mStd, id);
+    stl::UnorderedMapHelper helper(result);
     return result;
   }
 
-  template<typename T>
-  Data_Type<T> define_unordered_map_auto()
-  {
-    std::string klassName = detail::makeClassName(typeid(T));
-    Module rb_mRice = define_module("Rice");
-    Module rb_munordered_map = define_module_under(rb_mRice, "Std");
-    return define_unordered_map_under<T>(rb_munordered_map, klassName);
-  }
-   
   namespace detail
   {
-    template<typename T, typename U>
-    struct Type<std::unordered_map<T, U>>
+    template<typename Key_T, typename T>
+    struct Type<std::unordered_map<Key_T, T>>
     {
       static bool verify()
       {
+        Type<Key_T>::verify();
         Type<T>::verify();
-        Type<U>::verify();
 
-        if (!detail::Registries::instance.types.isDefined<std::unordered_map<T, U>>())
+        if (!Data_Type<std::unordered_map<Key_T, T>>::is_defined())
         {
-          define_unordered_map_auto<std::unordered_map<T, U>>();
+          define_unordered_map<Key_T, T>();
         }
 
         return true;
@@ -1927,16 +3472,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::unordered_map<T, U> convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped unordered_map (hopefully!)
-            return *Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+            return *detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
           }
-          case T_HASH:
+          case RUBY_T_HASH:
           {
             // If this an Ruby hash and the unordered_mapped type is copyable
             if constexpr (std::is_default_constructible_v<U>)
@@ -1944,13 +3504,6 @@ namespace Rice
               return UnorderedMapFromHash<T, U>::convert(value);
             }
           }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::unordered_map<T, U>>();
-            }
-          }
           default:
           {
             throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
@@ -1973,16 +3526,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::unordered_map<T, U>& convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped unordered_map (hopefully!)
-            return *Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+            return *detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
           }
-          case T_HASH:
+          case RUBY_T_HASH:
           {
             // If this an Ruby array and the unordered_map type is copyable
             if constexpr (std::is_default_constructible_v<std::unordered_map<T, U>>)
@@ -1991,13 +3559,6 @@ namespace Rice
               return this->converted_;
             }
           }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::unordered_map<T, U>>();
-            }
-          }
           default:
           {
             throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
@@ -2015,16 +3576,34 @@ namespace Rice
     class From_Ruby<std::unordered_map<T, U>*>
     {
     public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::unordered_map<T, U>* convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped unordered_map (hopefully!)
-            return Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+            return detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
           }
-          case T_HASH:
+          case RUBY_T_HASH:
           {
             // If this an Ruby array and the unordered_map type is copyable
             if constexpr (std::is_default_constructible_v<U>)
@@ -2049,24 +3628,15 @@ namespace Rice
 
 // =========   vector.hpp   =========
 
-
 namespace Rice
 {
   template<typename T>
-  Data_Type<T> define_vector(std::string name);
-
-  template<typename T>
-  Data_Type<T> define_vector_under(Object module, std::string name);
+  Data_Type<std::vector<T>> define_vector(std::string name = "" );
 }
 
 
 // ---------   vector.ipp   ---------
-
-#include <sstream>
-#include <stdexcept>
-#include <type_traits>
 #include <vector>
-#include <variant>
 
 namespace Rice
 {
@@ -2075,15 +3645,22 @@ namespace Rice
     template<typename T>
     class VectorHelper
     {
+      // We do NOT use Reference_T and instead use Parameter_T to avoid the weirdness
+      // of std::vector<bool>. Reference_T is actually a proxy class that we do not
+      // want to have to register with Rice nor do we want to pass it around.
       using Value_T = typename T::value_type;
       using Size_T = typename T::size_type;
       using Difference_T = typename T::difference_type;
+      // For To_Ruby_T however we do need to use reference type because this is what
+      // will be passed by an interator to To_Ruby#convert
+      using Reference_T = typename T::reference;
+      using Parameter_T = std::conditional_t<std::is_pointer_v<Value_T>, Value_T, Value_T&>;
+      using To_Ruby_T = detail::remove_cv_recursive_t<typename T::reference>;
 
     public:
       VectorHelper(Data_Type<T> klass) : klass_(klass)
       {
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_constructable_methods();
         this->define_capacity_methods();
         this->define_access_methods();
@@ -2115,33 +3692,44 @@ namespace Rice
         return index;
       };
 
-      void define_constructor()
+      void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>());
-      }
+        klass_.define_constructor(Constructor<T>())
+              .define_constructor(Constructor<T, Size_T, const Parameter_T>())
+              .define_constructor(Constructor<T, const T&>());
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
+        if constexpr (std::is_default_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& vector) -> T
-            {
-              return vector;
-            });
+          klass_.define_constructor(Constructor<T, Size_T>());
         }
-        else
+
+        // Allow creation of a vector from a Ruby Array
+        klass_.define_method("initialize", [](VALUE self, Array array) -> void
         {
-          klass_.define_method("copy", [](T& vector) -> T
-            {
-              throw std::runtime_error("Cannot copy vectors with non-copy constructible types");
-              return vector;
-            });
-        }
+          // Create a new vector from the array
+          T* data = new T();
+          data->reserve(array.size());
+
+          detail::From_Ruby<Value_T> fromRuby;
+
+          for (long i = 0; i < array.size(); i++)
+          {
+            VALUE element = detail::protect(rb_ary_entry, array, i);
+            data->push_back(fromRuby.convert(element));
+          }
+
+          // Wrap the vector
+          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+        });
       }
 
       void define_constructable_methods()
       {
-        if constexpr (std::is_default_constructible_v<Value_T>)
+        if constexpr (std::is_default_constructible_v<Value_T> && std::is_same_v<Value_T, bool>)
+        {
+          klass_.define_method("resize", static_cast<void (T::*)(const size_t, bool)>(&T::resize));
+        }
+        else if constexpr (std::is_default_constructible_v<Value_T>)
         {
           klass_.define_method("resize", static_cast<void (T::*)(const size_t)>(&T::resize));
         }
@@ -2172,49 +3760,87 @@ namespace Rice
       {
         // Access methods
         klass_.define_method("first", [](const T& vector) -> std::optional<Value_T>
+        {
+          if (vector.size() > 0)
+          {
+            return vector.front();
+          }
+          else
+          {
+            return std::nullopt;
+          }
+        })
+        .define_method("last", [](const T& vector) -> std::optional<Value_T>
           {
             if (vector.size() > 0)
             {
-              return vector.front();
+              return vector.back();
             }
             else
             {
               return std::nullopt;
             }
           })
-          .define_method("last", [](const T& vector) -> std::optional<Value_T>
+        .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())
             {
-              if (vector.size() > 0)
-              {
-                return vector.back();
-              }
-              else
+              return std::nullopt;
+            }
+            else
+            {
+              return vector[index];
+            }
+          })
+        .define_method("[]", [this](const T& vector, Difference_T start, Difference_T length) -> VALUE
+          {
+            start = normalizeIndex(vector.size(), start);
+            if (start < 0 || start >= (Difference_T)vector.size())
+            {
+              return rb_ary_new();
+            }
+            else
+            {
+              auto begin = vector.begin() + start;
+
+              // Ruby does not throw an exception when the length is too long
+              Difference_T size = (Difference_T)vector.size();
+              if (start + length > size)
               {
-                return std::nullopt;
+                length = size - start;
               }
-            })
-            .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
+
+              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)
               {
-                index = normalizeIndex(vector.size(), index);
-                if (index < 0 || index >= (Difference_T)vector.size())
-                {
-                  return std::nullopt;
-                }
-                else
-                {
-                  return vector[index];
-                }
+                VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+                rb_ary_push(result, value);
               });
 
-            rb_define_alias(klass_, "at", "[]");
+              return result;
+            }
+          }, Return().setValue());
+
+          if constexpr (!std::is_same_v<Value_T, bool>)
+          {
+            define_buffer<Value_T>();
+            define_buffer<Value_T*>();
+            klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+          }
+
+          rb_define_alias(klass_, "at", "[]");
       }
 
       // Methods that require Value_T to support operator==
       void define_comparable_methods()
       {
-        if constexpr (detail::is_comparable_v<Value_T>)
+        if constexpr (detail::is_comparable_v<T>)
         {
-          klass_.define_method("delete", [](T& vector, Value_T& element) -> std::optional<Value_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())
@@ -2228,11 +3854,11 @@ namespace Rice
                 return result;
               }
             })
-          .define_method("include?", [](T& vector, Value_T& element)
+          .define_method("include?", [](T& vector, Parameter_T element)
             {
               return std::find(vector.begin(), vector.end(), element) != vector.end();
             })
-          .define_method("index", [](T& vector, Value_T& element) -> std::optional<Difference_T>
+          .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())
@@ -2247,15 +3873,15 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("delete", [](T& vector, Value_T& element) -> std::optional<Value_T>
+          klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
             {
               return std::nullopt;
             })
-          .define_method("include?", [](const T& vector, Value_T& element)
+          .define_method("include?", [](const T& vector, Parameter_T element)
             {
               return false;
             })
-          .define_method("index", [](const T& vector, Value_T& element) -> std::optional<Difference_T>
+          .define_method("index", [](const T& vector, Parameter_T element) -> std::optional<Difference_T>
             {
               return std::nullopt;
             });
@@ -2272,7 +3898,7 @@ namespace Rice
               vector.erase(iter);
               return result;
             })
-          .define_method("insert", [this](T& vector, Difference_T index, Value_T& element) -> T&
+          .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
             {
               index = normalizeIndex(vector.size(), index, true);
               auto iter = vector.begin() + index;
@@ -2292,21 +3918,22 @@ namespace Rice
                 return std::nullopt;
               }
             })
-          .define_method("push", [](T& vector, Value_T& element) -> T&
+          .define_method("push", [](T& vector, Parameter_T element) -> T&
             {
               vector.push_back(element);
               return vector;
             })
           .define_method("shrink_to_fit", &T::shrink_to_fit)
-          .define_method("[]=", [this](T& vector, Difference_T index, Value_T& element) -> Value_T&
+          .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> Parameter_T
             {
               index = normalizeIndex(vector.size(), index, true);
               vector[index] = element;
               return element;
             });
 
-            rb_define_alias(klass_, "<<", "push");
-            rb_define_alias(klass_, "append", "push");
+        rb_define_alias(klass_, "push_back", "push");
+        rb_define_alias(klass_, "<<", "push");
+        rb_define_alias(klass_, "append", "push");
       }
 
       void define_enumerable()
@@ -2321,9 +3948,9 @@ namespace Rice
         klass_.define_method("to_a", [](T& vector)
         {
           VALUE result = rb_ary_new();
-          std::for_each(vector.begin(), vector.end(), [&result](const Value_T& element)
+          std::for_each(vector.begin(), vector.end(), [&result](const Reference_T element)
           {
-            VALUE value = detail::To_Ruby<Value_T&>().convert(element);
+            VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
             rb_ary_push(result, value);
           });
 
@@ -2374,48 +4001,30 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_vector_under(Object module, std::string name)
+  Data_Type<std::vector<T>> define_vector(std::string klassName)
   {
-    if (detail::Registries::instance.types.isDefined<T>())
-    {
-      // If the vector has been previously seen it will be registered but may
-      // not be associated with the constant Module::<name>
-      module.const_set_maybe(name, Data_Type<T>().klass());
+    using Vector_T = std::vector<T>;
+    using Data_Type_T = Data_Type<Vector_T>;
 
-      return Data_Type<T>();
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(Vector_T));
+      klassName = detail::rubyClassName(typeName);
     }
 
-    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
-    stl::VectorHelper helper(result);
-    return result;
-  }
-
-  template<typename T>
-  Data_Type<T> define_vector(std::string name)
-  {
-    if (detail::Registries::instance.types.isDefined<T>())
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
     {
-      // If the vector has been previously seen it will be registered but may
-      // not be associated with the constant Module::<name>
-      Object(rb_cObject).const_set_maybe(name, Data_Type<T>().klass());
-
-      return Data_Type<T>();
+      return Data_Type_T();
     }
 
-    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
-    stl::VectorHelper<T> helper(result);
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<Vector_T>>(rb_mStd, id);
+    stl::VectorHelper helper(result);
     return result;
   }
 
-  template<typename T>
-  Data_Type<T> define_vector_auto()
-  {
-    std::string klassName = detail::makeClassName(typeid(T));
-    Module rb_mRice = define_module("Rice");
-    Module rb_mVector = define_module_under(rb_mRice, "Std");
-    return define_vector_under<T>(rb_mVector, klassName);
-  }
-   
+
   namespace detail
   {
     template<typename T>
@@ -2425,30 +4034,15 @@ namespace Rice
       {
         Type<intrinsic_type<T>>::verify();
 
-        if (!detail::Registries::instance.types.isDefined<std::vector<T>>())
+        if (!Data_Type<std::vector<T>>::is_defined())
         {
-          define_vector_auto<std::vector<T>>();
+          define_vector<T>();
         }
 
         return true;
       }
     };
 
-    template<typename T>
-    std::vector<T> vectorFromArray(VALUE value)
-    {
-      long length = protect(rb_array_len, value);
-      std::vector<T> result(length);
-
-      for (long i = 0; i < length; i++)
-      {
-        VALUE element = protect(rb_ary_entry, value, i);
-        result[i] = From_Ruby<T>().convert(element);
-      }
-
-      return result;
-    }
-
     template<typename T>
     class From_Ruby<std::vector<T>>
     {
@@ -2459,28 +4053,38 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::vector<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_ARRAY:
+            if constexpr (std::is_default_constructible_v<T>)
+            {
+              return Convertible::Cast;
+            }
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::vector<T> convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped vector (hopefully!)
-            return *Data_Object<std::vector<T>>::from_ruby(value);
+            return *detail::unwrap<std::vector<T>>(value, Data_Type<std::vector<T>>::ruby_data_type(), false);
           }
-          case T_ARRAY:
+          case RUBY_T_ARRAY:
           {
             // If this an Ruby array and the vector type is copyable
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return vectorFromArray<T>(value);
-            }
-          }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::vector<T>>();
+              return Array(value).to_vector<T>();
             }
           }
           default:
@@ -2491,11 +4095,6 @@ namespace Rice
         }
       }
 
-      bool is_convertible(VALUE value)
-      {
-        return rb_type(value) == RUBY_T_ARRAY;
-      }
-
     private:
       Arg* arg_ = nullptr;
     };
@@ -2510,31 +4109,41 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::vector<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_ARRAY:
+            if constexpr (std::is_default_constructible_v<T>)
+            {
+              return Convertible::Cast;
+            }
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::vector<T>& convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped vector (hopefully!)
-            return *Data_Object<std::vector<T>>::from_ruby(value);
+            return *detail::unwrap<std::vector<T>>(value, Data_Type<std::vector<T>>::ruby_data_type(), false);
           }
-          case T_ARRAY:
+          case RUBY_T_ARRAY:
           {
             // If this an Ruby array and the vector type is copyable
             if constexpr (std::is_default_constructible_v<T>)
             {
-              this->converted_ = vectorFromArray<T>(value);
+              this->converted_ = Array(value).to_vector<T>();
               return this->converted_;
             }
           }
-          case T_NIL:
-          {
-            if (this->arg_ && this->arg_->hasDefaultValue())
-            {
-              return this->arg_->template defaultValue<std::vector<T>>();
-            }
-          }
           default:
           {
             throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
@@ -2543,11 +4152,6 @@ namespace Rice
         }
       }
 
-      bool is_convertible(VALUE value)
-      {
-        return rb_type(value) == RUBY_T_ARRAY;
-      }
-
     private:
       Arg* arg_ = nullptr;
       std::vector<T> converted_;
@@ -2557,21 +4161,41 @@ namespace Rice
     class From_Ruby<std::vector<T>*>
     {
     public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::vector<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_ARRAY:
+            if constexpr (std::is_default_constructible_v<T>)
+            {
+              return Convertible::Cast;
+            }
+          default:
+            return Convertible::None;
+        }
+      }
+
       std::vector<T>* convert(VALUE value)
       {
         switch (rb_type(value))
         {
-          case T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped vector (hopefully!)
-            return Data_Object<std::vector<T>>::from_ruby(value);
+            return detail::unwrap<std::vector<T>>(value, Data_Type<std::vector<T>>::ruby_data_type(), false);
           }
-          case T_ARRAY:
+          case RUBY_T_ARRAY:
           {
-            // If this an Ruby array and the vector type is copyable
+            // If this a Ruby array and the vector type is copyable
             if constexpr (std::is_default_constructible_v<T>)
             {
-              this->converted_ = vectorFromArray<T>(value);
+              this->converted_ = Array(value).to_vector<T>();
               return &this->converted_;
             }
           }
@@ -2583,15 +4207,24 @@ namespace Rice
         }
       }
 
-      bool is_convertible(VALUE value)
-      {
-        return rb_type(value) == RUBY_T_ARRAY;
-      }
-
     private:
       std::vector<T> converted_;
     };
   }
+
+  // Special handling for std::vector<bool>
+  namespace detail
+  {
+    template<>
+    class To_Ruby<std::vector<bool>::reference>
+    {
+    public:
+      VALUE convert(const std::vector<bool>::reference& value)
+      {
+        return value ? Qtrue : Qfalse;
+      }
+    };
+  }
 }