rice 4.0.4 → 4.2.0

data/include/rice/stl.hpp

@@ -49,6 +49,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     std::string convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -70,6 +75,11 @@ namespace Rice::detail
   class From_Ruby<std::string*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     std::string* convert(VALUE value)
     {
       detail::protect(rb_check_type, value, (int)T_STRING);
@@ -91,6 +101,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     std::string& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -138,7 +153,7 @@ namespace Rice::detail
       std::vector<VALUE> args(2);
       args[0] = To_Ruby<T>().convert(data.real());
       args[1] = To_Ruby<T>().convert(data.imag());
-      return protect(rb_funcall2, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
+      return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
     }
   };
 
@@ -148,11 +163,16 @@ namespace Rice::detail
   public:
     std::complex<T> convert(VALUE value)
     {
-      VALUE real = protect(rb_funcall2, value, rb_intern("real"), 0, (const VALUE*)nullptr);
-      VALUE imaginary = protect(rb_funcall2, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
+      VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
+      VALUE imaginary = protect(rb_funcallv, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
 
       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>
@@ -161,18 +181,24 @@ namespace Rice::detail
   public:
     std::complex<T>& convert(VALUE value)
     {
-      VALUE real = protect(rb_funcall2, value, rb_intern("real"), 0, (const VALUE*)nullptr);
-      VALUE imaginary = protect(rb_funcall2, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
+      VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
+      VALUE imaginary = protect(rb_funcallv, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
       this->converted_ = std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
 
       return this->converted_;
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_COMPLEX;
+    }
+
   private:
     std::complex<T> converted_;
   };
 }
 
+
 // =========   optional.hpp   =========
 
 
@@ -204,7 +230,7 @@ namespace Rice::detail
   class To_Ruby<std::optional<T>>
   {
   public:
-    static VALUE convert(std::optional<T>& data, bool takeOwnership = false)
+    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
     {
       if (data.has_value())
       {
@@ -221,7 +247,7 @@ namespace Rice::detail
   class To_Ruby<std::optional<T>&>
   {
   public:
-    static VALUE convert(std::optional<T>& data, bool takeOwnership = false)
+    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
     {
       if (data.has_value())
       {
@@ -273,109 +299,1406 @@ namespace Rice::detail
   };
 }
 
-// =========   pair.hpp   =========
 
+// =========   reference_wrapper.hpp   =========
 
-namespace Rice
+
+// ---------   reference_wrapper.ipp   ---------
+#include <functional>
+
+namespace Rice::detail
 {
   template<typename T>
-  Data_Type<T> define_pair(std::string name);
+  struct Type<std::reference_wrapper<T>>
+  {
+    constexpr static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
 
   template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name);
+  class To_Ruby<std::reference_wrapper<T>>
+  {
+  public:
+    VALUE convert(const std::reference_wrapper<T>& data, bool takeOwnership = false)
+    {
+      return To_Ruby<T&>().convert(data.get());
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<std::reference_wrapper<T>>
+  {
+  public:
+    bool is_convertible(VALUE value)
+    {
+      return true;
+    }
+
+    std::reference_wrapper<T> convert(VALUE value)
+    {
+      return this->converter_.convert(value);
+    }
+
+  private:
+    From_Ruby<T&> converter_;
+  };
 }
 
 
-// ---------   pair.ipp   ---------
+// =========   smart_ptr.hpp   =========
 
-#include <sstream>
-#include <stdexcept>
-#include <utility>
 
-namespace Rice
+namespace Rice::detail
 {
-  namespace stl
+  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
+  class WrapperSmartPointer : public Wrapper
   {
-    template<typename T>
-    class PairHelper
+  public:
+    WrapperSmartPointer(SmartPointer_T<Arg_Ts...>& data);
+    ~WrapperSmartPointer();
+    void* get() override;
+    SmartPointer_T<Arg_Ts...>& data();
+
+  private:
+    SmartPointer_T<Arg_Ts...> data_;
+  };
+}
+
+
+// ---------   smart_ptr.ipp   ---------
+
+#include <assert.h>
+#include <memory>
+
+namespace Rice::detail
+{
+  // ---- 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)
     {
-    public:
-      PairHelper(Data_Type<T> klass) : klass_(klass)
+      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 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());
+
+      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
+      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
+      if (!smartWrapper)
       {
-        this->define_constructor();
-        this->define_copyable_methods();
-        this->define_access_methods();
-        this->define_modify_methods();
-        this->define_to_s();
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
       }
+      return smartWrapper->data();
+    }
+  };
 
-    private:
-      void define_constructor()
-      {
-        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
+
+  // ----- shared_ptr -------------
+  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);
+    }
+  };
+
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+
+    std::shared_ptr<T> convert(VALUE value)
+    {
+      if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
+        return this->arg_->template defaultValue<std::shared_ptr<T>>();
       }
 
-      void define_copyable_methods()
+      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)
       {
-        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& self) -> T
-            {
-              return self;
-            });
-        }
-        else
-        {
-          klass_.define_method("copy", [](T& self) -> T
-            {
-              throw std::runtime_error("Cannot copy pair with non-copy constructible types");
-              return self;
-            });
-        }
+        std::string message = "Invalid smart pointer wrapper";
+          throw std::runtime_error(message.c_str());
+      }
+      return smartWrapper->data();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+
+    std::shared_ptr<T>& convert(VALUE value)
+    {
+      if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
+        return this->arg_->template defaultValue<std::shared_ptr<T>>();
       }
 
-      void define_access_methods()
+      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)
       {
-        // Access methods
-        klass_.define_method("first", [](T& self) -> typename T::first_type&
-          {
-            return self.first;
-          })
-        .define_method("second", [](T& self) -> typename T::second_type&
-          {
-            return self.second;
-          });
+        std::string message = "Invalid smart pointer wrapper";
+          throw std::runtime_error(message.c_str());
       }
+      return smartWrapper->data();
+    }
 
-      void define_modify_methods()
-      {
-        // Access methods
-        klass_.define_method("first=", [](T& self, typename T::first_type& value) -> typename T::first_type&
-          {
-            self.first = value;
-            return self.first;
-          })
-        .define_method("second=", [](T& self, typename T::second_type& value) -> typename T::second_type&
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  struct Type<std::shared_ptr<T>>
+  {
+    static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
+}
+
+
+// =========   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:
+    bool is_convertible(VALUE value)
+    {
+      return false;
+    }
+
+    std::monostate convert(VALUE value)
+    {
+      return std::monostate();
+    }
+  };
+
+  template<>
+  class From_Ruby<std::monostate&>
+  {
+  public:
+    bool is_convertible(VALUE value)
+    {
+      return false;
+    }
+
+    std::monostate& convert(VALUE value)
+    {
+      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)
+    {
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+    }
+
+    template<std::size_t... I>
+    constexpr static bool verify()
+    {
+      auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
+      return verifyTypes(indices);
+    }
+  };
+
+  template<typename...Types>
+  class To_Ruby<std::variant<Types...>>
+  {
+  public:
+
+    template<typename T>
+    static VALUE convertElement(const std::variant<Types...>& data, bool takeOwnership)
+    {
+      return To_Ruby<T>().convert(std::get<T>(data));
+    }
+
+    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/ */
+
+      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;
+    }
+
+    static VALUE convert(const std::variant<Types...>& 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 T>
+    static VALUE convertElement(const std::variant<Types...>& data, bool takeOwnership)
+    {
+      return To_Ruby<T>().convert(std::get<T>(data));
+    }
+
+    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...>;
+
+      // 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;
+    }
+
+    static VALUE convert(const std::variant<Types...>& 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 From_Ruby<std::variant<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)
+    {
+      // 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;
+
+        // 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");
+    }
+
+    std::variant<Types...> convert(VALUE value)
+    {
+      return convertInternal(value);
+    }
+  };
+
+  template<typename...Types>
+  class From_Ruby<std::variant<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)
+    {
+      // 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;
+
+        // 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");
+    }
+
+    std::variant<Types...> convert(VALUE value)
+    {
+      return convertInternal(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 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();
+      }
+
+    private:
+      void define_constructor()
+      {
+        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_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;
+            });
+        }
+      }
+
+      void define_access_methods()
+      {
+        // Access methods
+        klass_.define_method("first", [](T& pair) -> typename T::first_type&
+          {
+            return pair.first;
+          })
+        .define_method("second", [](T& pair) -> typename T::second_type&
+          {
+            return pair.second;
+          });
+      }
+
+      void define_modify_methods()
+      {
+        // Access methods
+        klass_.define_method("first=", [](T& pair, typename T::first_type& value) -> typename T::first_type&
+        {
+          if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::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 T>
+  Data_Type<T> define_pair_under(Object module, std::string name)
+  {
+    if (detail::Registries::instance.types.isDefined<T>())
+    {
+      // 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>();
+    }
+
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
+    stl::PairHelper helper(result);
+    return result;
+  }
+
+  template<typename T>
+  Data_Type<T> define_pair(std::string name)
+  {
+    if (detail::Registries::instance.types.isDefined<T>())
+    {
+      // 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>();
+    }
+
+    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
+    stl::PairHelper<T> helper(result);
+    return result;
+  }
+
+  template<typename T>
+  Data_Type<T> define_pair_auto()
+  {
+    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);
+  }
+   
+  namespace detail
+  {
+    template<typename T1, typename T2>
+    struct Type<std::pair<T1, T2>>
+    {
+      static bool verify()
+      {
+        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;
+      }
+    };
+  }
+}
+
+
+
+// =========   map.hpp   =========
+
+
+namespace Rice
+{
+  template<typename U>
+  Data_Type<U> define_map(std::string name);
+
+  template<typename U>
+  Data_Type<U> define_map_under(Object module, std::string name);
+}
+
+
+// ---------   map.ipp   ---------
+
+#include <sstream>
+#include <stdexcept>
+#include <map>
+#include <type_traits>
+#include <variant>
+
+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 Size_T = typename T::size_type;
+      using Difference_T = typename T::difference_type;
+
+    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_auto<Value_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 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);
+          });
+
+          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 T>
+  Data_Type<T> define_map_under(Object module, std::string name)
+  {
+    if (detail::Registries::instance.types.isDefined<T>())
+    {
+      // 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>();
+    }
+
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
+    stl::MapHelper helper(result);
+    return result;
+  }
+
+  template<typename T>
+  Data_Type<T> define_map(std::string name)
+  {
+    if (detail::Registries::instance.types.isDefined<T>())
+    {
+      // 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>();
+    }
+
+    Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
+    stl::MapHelper<T> helper(result);
+    return result;
+  }
+
+  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
+  {
+    template<typename T, typename U>
+    struct Type<std::map<T, U>>
+    {
+      static bool verify()
+      {
+        Type<T>::verify();
+        Type<U>::verify();
+
+        if (!detail::Registries::instance.types.isDefined<std::map<T, U>>())
+        {
+          define_map_auto<std::map<T, U>>();
+        }
+
+        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)
+      {
+      }
+
+      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");
+          }
+        }
+      }
+
+    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)
+      {
+      }
+
+      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 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");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+      std::map<T, U> converted_;
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::map<T, U>*>
+    {
+    public:
+      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 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_;
+    };
+  }
+}
+
+// =========   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);
+}
+
+
+// ---------   unordered_map.ipp   ---------
+
+#include <sstream>
+#include <stdexcept>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+
+namespace Rice
+{
+  namespace stl
+  {
+    template<typename T>
+    class UnorderedMapHelper
+    {
+      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;
+
+    public:
+      UnorderedMapHelper(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_auto<Value_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& unordered_map) -> T
+            {
+              return unordered_map;
+            });
+        }
+        else
+        {
+          klass_.define_method("copy", [](T& unordered_map) -> T
+            {
+              throw std::runtime_error("Cannot copy unordered_maps with non-copy constructible types");
+              return unordered_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& unordered_map, const Key_T& key) -> std::optional<Mapped_T>
+          {
+            auto iter = unordered_map.find(key);
+
+            if (iter != unordered_map.end())
+            {
+              return iter->second;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("include?", [](T& unordered_map, Key_T& key) -> bool
+          {
+              return unordered_map.find(key) != unordered_map.end();
+          })
+          .define_method("keys", [](T& unordered_map) -> std::vector<Key_T>
+            {
+              std::vector<Key_T> result;
+              std::transform(unordered_map.begin(), unordered_map.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.first;
+                });
+
+              return result;
+            })
+          .define_method("values", [](T& unordered_map) -> std::vector<Mapped_T>
+            {
+              std::vector<Mapped_T> result;
+              std::transform(unordered_map.begin(), unordered_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& unordered_map, Mapped_T& value) -> bool
+            {
+              auto it = std::find_if(unordered_map.begin(), unordered_map.end(),
+              [&value](auto& pair)
+                {
+                  return pair.second == value;
+                });
+
+              return it != unordered_map.end();
+          });
+        }
+        else
+        {
+          klass_.define_method("value?", [](T& unordered_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& unordered_map, Key_T& key) -> std::optional<Mapped_T>
+            {
+              auto iter = unordered_map.find(key);
+
+              if (iter != unordered_map.end())
+              {
+                Mapped_T result = iter->second;
+                unordered_map.erase(iter);
+                return result;
+              }
+              else
+              {
+                return std::nullopt;
+              }
+            })
+          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_T value) -> Mapped_T
+            {
+              unordered_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& unordered_map)
+        {
+          VALUE result = rb_hash_new();
+          std::for_each(unordered_map.begin(), unordered_map.end(), [&result](const auto& pair)
           {
-            self.second = value;
-            return self.second;
+            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);
           });
+
+          return result;
+        }, Return().setValue());
       }
 
       void define_to_s()
       {
-        if constexpr (detail::is_ostreamable_v<typename T::first_type> && detail::is_ostreamable_v<typename T::second_type>)
+        if constexpr (detail::is_ostreamable_v<Key_T> && detail::is_ostreamable_v<Mapped_T>)
         {
-          klass_.define_method("to_s", [](const T& self)
+          klass_.define_method("to_s", [](const T& unordered_map)
             {
+              auto iter = unordered_map.begin();
+
               std::stringstream stream;
-              stream << "[" << self.first << ", " << self.second << "]";
+              stream << "{";
+
+              for (; iter != unordered_map.end(); iter++)
+              {
+                if (iter != unordered_map.begin())
+                {
+                  stream << ", ";
+                }
+                stream << iter->first << " => " << iter->second;
+              }
+
+              stream << "}";
               return stream.str();
             });
         }
         else
         {
-          klass_.define_method("to_s", [](const T& self)
+          klass_.define_method("to_s", [](const T& unordered_map)
             {
               return "[Not printable]";
             });
@@ -388,212 +1711,222 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name)
+  Data_Type<T> define_unordered_map_under(Object module, std::string name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
-      return Data_Type<T>(Data_Type<T>());
+      // 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>();
     }
 
     Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
-    stl::PairHelper helper(result);
+    stl::UnorderedMapHelper helper(result);
     return result;
   }
 
   template<typename T>
-  Data_Type<T> define_pair(std::string name)
+  Data_Type<T> define_unordered_map(std::string name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
-      return Data_Type<T>(Data_Type<T>());
+      // 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>();
     }
 
     Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
-    stl::PairHelper<T> helper(result);
+    stl::UnorderedMapHelper<T> helper(result);
     return result;
   }
 
   template<typename T>
-  Data_Type<T> define_pair_auto()
+  Data_Type<T> define_unordered_map_auto()
   {
     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_munordered_map = define_module_under(rb_mRice, "Std");
+    return define_unordered_map_under<T>(rb_munordered_map, klassName);
   }
    
   namespace detail
   {
-    template<typename T1, typename T2>
-    struct Type<std::pair<T1, T2>>
+    template<typename T, typename U>
+    struct Type<std::unordered_map<T, U>>
     {
       static bool verify()
       {
-        Type<T1>::verify();
-        Type<T2>::verify();
+        Type<T>::verify();
+        Type<U>::verify();
 
-        if (!detail::TypeRegistry::isDefined<std::pair<T1, T2>>())
+        if (!detail::Registries::instance.types.isDefined<std::unordered_map<T, U>>())
         {
-          define_pair_auto<std::pair<T1, T2>>();
+          define_unordered_map_auto<std::unordered_map<T, U>>();
         }
 
         return true;
       }
     };
-  }
-}
-
-
-
-// =========   smart_ptr.hpp   =========
-
-
-namespace Rice::detail
-{
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  class WrapperSmartPointer : public Wrapper
-  {
-  public:
-    WrapperSmartPointer(SmartPointer_T<Arg_Ts...>& data);
-    void* get() override;
-    SmartPointer_T<Arg_Ts...>& data();
-
-  private:
-    SmartPointer_T<Arg_Ts...> data_;
-  };
-}
 
+    template<typename T, typename U>
+    struct UnorderedMapFromHash
+    {
+      static int convertPair(VALUE key, VALUE value, VALUE user_data)
+      {
+        std::unordered_map<T, U>* result = (std::unordered_map<T, U>*)(user_data);
 
-// ---------   smart_ptr.ipp   ---------
-
-#include <assert.h>
-#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
-{
-  // ---- 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))
-  {
-  }
+      static std::unordered_map<T, U> convert(VALUE value)
+      {
+        std::unordered_map<T, U> result;
+        VALUE user_data = (VALUE)(&result);
 
-  template <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline void* WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::get()
-  {
-    return (void*)this->data_.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 <template <typename, typename...> typename SmartPointer_T, typename...Arg_Ts>
-  inline SmartPointer_T<Arg_Ts...>& WrapperSmartPointer<SmartPointer_T, Arg_Ts...>::data()
-  {
-    return data_;
-  }
+        return result;
+      }
+    };
 
-  // ---- unique_ptr ------
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>>
-  {
-  public:
-    VALUE convert(std::unique_ptr<T>& data)
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>>
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::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);
-    }
-  };
+    public:
+      From_Ruby() = default;
 
-  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>::rb_type());
+      explicit From_Ruby(Arg * arg) : arg_(arg)
+      {
+      }
 
-      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
+      std::unordered_map<T, U> convert(VALUE value)
       {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
+        switch (rb_type(value))
+        {
+          case T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return *Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+          }
+          case T_HASH:
+          {
+            // If this an Ruby hash and the unordered_mapped type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              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)",
+              detail::protect(rb_obj_classname, value), "std::unordered_map");
+          }
+        }
       }
-      return smartWrapper->data();
-    }
-  };
 
-  template<typename T>
-  struct Type<std::unique_ptr<T>>
-  {
-    static bool verify()
-    {
-      return Type<T>::verify();
-    }
-  };
+    private:
+      Arg* arg_ = nullptr;
+    };
 
-  // ----- shared_ptr -------------
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>>
-  {
-  public:
-    VALUE convert(std::shared_ptr<T>& data)
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>&>
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::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);
-    }
-  };
+    public:
+      From_Ruby() = default;
 
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>>
-  {
-  public:
-    std::shared_ptr<T> convert(VALUE value)
-    {
-      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::rb_type());
+      explicit From_Ruby(Arg * arg) : arg_(arg)
+      {
+      }
 
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
+      std::unordered_map<T, U>& convert(VALUE value)
       {
-        std::string message = "Invalid smart pointer wrapper";
-          throw std::runtime_error(message.c_str());
+        switch (rb_type(value))
+        {
+          case T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return *Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+          }
+          case 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>>)
+            {
+              this->converted_ = UnorderedMapFromHash<T, U>::convert(value);
+              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)",
+              detail::protect(rb_obj_classname, value), "std::unordered_map");
+          }
+        }
       }
-      return smartWrapper->data();
-    }
-  };
 
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    std::shared_ptr<T>& convert(VALUE value)
-    {
-      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::rb_type());
+    private:
+      Arg* arg_ = nullptr;
+      std::unordered_map<T, U> converted_;
+    };
 
-      using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
-      if (!smartWrapper)
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>*>
+    {
+    public:
+      std::unordered_map<T, U>* convert(VALUE value)
       {
-        std::string message = "Invalid smart pointer wrapper";
-          throw std::runtime_error(message.c_str());
+        switch (rb_type(value))
+        {
+          case T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return Data_Object<std::unordered_map<T, U>>::from_ruby(value);
+          }
+          case T_HASH:
+          {
+            // If this an Ruby array and the unordered_map type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              this->converted_ = UnorderedMapFromHash<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::unordered_map");
+          }
+        }
       }
-      return smartWrapper->data();
-    }
-  };
 
-  template<typename T>
-  struct Type<std::shared_ptr<T>>
-  {
-    static bool verify()
-    {
-      return Type<T>::verify();
-    }
-  };
+    private:
+      std::unordered_map<T, U> converted_;
+    };
+  }
 }
 
 // =========   vector.hpp   =========
@@ -613,7 +1946,9 @@ namespace Rice
 
 #include <sstream>
 #include <stdexcept>
+#include <type_traits>
 #include <vector>
+#include <variant>
 
 namespace Rice
 {
@@ -636,8 +1971,9 @@ namespace Rice
         this->define_access_methods();
         this->define_comparable_methods();
         this->define_modify_methods();
-        this->define_to_s();
         this->define_enumerable();
+        this->define_to_array();
+        this->define_to_s();
       }
 
     private:
@@ -670,17 +2006,17 @@ namespace Rice
       {
         if constexpr (std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& self) -> T
+          klass_.define_method("copy", [](T& vector) -> T
             {
-              return self;
+              return vector;
             });
         }
         else
         {
-          klass_.define_method("copy", [](T& self) -> T
+          klass_.define_method("copy", [](T& vector) -> T
             {
               throw std::runtime_error("Cannot copy vectors with non-copy constructible types");
-              return self;
+              return vector;
             });
         }
       }
@@ -693,7 +2029,7 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("resize", [](const T& self, Size_T newSize)
+          klass_.define_method("resize", [](const T& vector, Size_T newSize)
               {
                 // Do nothing
               });
@@ -717,38 +2053,38 @@ namespace Rice
       void define_access_methods()
       {
         // Access methods
-        klass_.define_method("first", [](const T& self) -> std::optional<Value_T>
+        klass_.define_method("first", [](const T& vector) -> std::optional<Value_T>
           {
-            if (self.size() > 0)
+            if (vector.size() > 0)
             {
-              return self.front();
+              return vector.front();
             }
             else
             {
               return std::nullopt;
             }
           })
-          .define_method("last", [](const T& self) -> std::optional<Value_T>
+          .define_method("last", [](const T& vector) -> std::optional<Value_T>
             {
-              if (self.size() > 0)
+              if (vector.size() > 0)
               {
-                return self.back();
+                return vector.back();
               }
               else
               {
                 return std::nullopt;
               }
             })
-            .define_method("[]", [this](const T& self, Difference_T index) -> std::optional<Value_T>
+            .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
               {
-                index = normalizeIndex(self.size(), index);
-                if (index < 0 || index >= (Difference_T)self.size())
+                index = normalizeIndex(vector.size(), index);
+                if (index < 0 || index >= (Difference_T)vector.size())
                 {
                   return std::nullopt;
                 }
                 else
                 {
-                  return self[index];
+                  return vector[index];
                 }
               });
 
@@ -760,48 +2096,48 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Value_T>)
         {
-          klass_.define_method("delete", [](T& self, Value_T& element) -> std::optional<Value_T>
+          klass_.define_method("delete", [](T& vector, Value_T& element) -> std::optional<Value_T>
             {
-              auto iter = std::find(self.begin(), self.end(), element);
-              if (iter == self.end())
+              auto iter = std::find(vector.begin(), vector.end(), element);
+              if (iter == vector.end())
               {
                 return std::nullopt;
               }
               else
               {
                 Value_T result = *iter;
-                self.erase(iter);
+                vector.erase(iter);
                 return result;
               }
             })
-          .define_method("include?", [](T& self, Value_T& element)
+          .define_method("include?", [](T& vector, Value_T& element)
             {
-              return std::find(self.begin(), self.end(), element) != self.end();
+              return std::find(vector.begin(), vector.end(), element) != vector.end();
             })
-          .define_method("index", [](T& self, Value_T& element) -> std::optional<Difference_T>
+          .define_method("index", [](T& vector, Value_T& element) -> std::optional<Difference_T>
             {
-              auto iter = std::find(self.begin(), self.end(), element);
-              if (iter == self.end())
+              auto iter = std::find(vector.begin(), vector.end(), element);
+              if (iter == vector.end())
               {
                 return std::nullopt;
               }
               else
               {
-                return iter - self.begin();
+                return iter - vector.begin();
               }
             });
         }
         else
         {
-          klass_.define_method("delete", [](T& self, Value_T& element) -> std::optional<Value_T>
+          klass_.define_method("delete", [](T& vector, Value_T& element) -> std::optional<Value_T>
             {
               return std::nullopt;
             })
-          .define_method("include?", [](const T& self, Value_T& element)
+          .define_method("include?", [](const T& vector, Value_T& element)
             {
               return false;
             })
-          .define_method("index", [](const T& self, Value_T& element) -> std::optional<Difference_T>
+          .define_method("index", [](const T& vector, Value_T& element) -> std::optional<Difference_T>
             {
               return std::nullopt;
             });
@@ -811,26 +2147,26 @@ namespace Rice
       void define_modify_methods()
       {
         klass_.define_method("clear", &T::clear)
-          .define_method("delete_at", [](T& self, const size_t& pos)
+          .define_method("delete_at", [](T& vector, const size_t& pos)
             {
-              auto iter = self.begin() + pos;
+              auto iter = vector.begin() + pos;
               Value_T result = *iter;
-              self.erase(iter);
+              vector.erase(iter);
               return result;
             })
-          .define_method("insert", [this](T& self, Difference_T index, Value_T& element) -> T&
+          .define_method("insert", [this](T& vector, Difference_T index, Value_T& element) -> T&
             {
-              index = normalizeIndex(self.size(), index, true);
-              auto iter = self.begin() + index;
-              self.insert(iter, element);
-              return self;
+              index = normalizeIndex(vector.size(), index, true);
+              auto iter = vector.begin() + index;
+              vector.insert(iter, element);
+              return vector;
             })
-          .define_method("pop", [](T& self) -> std::optional<Value_T>
+          .define_method("pop", [](T& vector) -> std::optional<Value_T>
             {
-              if (self.size() > 0)
+              if (vector.size() > 0)
               {
-                Value_T result = self.back();
-                self.pop_back();
+                Value_T result = vector.back();
+                vector.pop_back();
                 return result;
               }
               else
@@ -838,16 +2174,16 @@ namespace Rice
                 return std::nullopt;
               }
             })
-          .define_method("push", [](T& self, Value_T& element) -> T&
+          .define_method("push", [](T& vector, Value_T& element) -> T&
             {
-              self.push_back(element);
-              return self;
+              vector.push_back(element);
+              return vector;
             })
           .define_method("shrink_to_fit", &T::shrink_to_fit)
-          .define_method("[]=", [this](T& self, Difference_T index, Value_T& element) -> Value_T&
+          .define_method("[]=", [this](T& vector, Difference_T index, Value_T& element) -> Value_T&
             {
-              index = normalizeIndex(self.size(), index, true);
-              self[index] = element;
+              index = normalizeIndex(vector.size(), index, true);
+              vector[index] = element;
               return element;
             });
 
@@ -858,33 +2194,40 @@ namespace Rice
       void define_enumerable()
       {
         // Add enumerable support
-        klass_.include_module(rb_mEnumerable)
-          .define_method("each", [](T& self) -> const T&
-            {
-              for (Value_T& item : self)
-              {
-                VALUE element = detail::To_Ruby<Value_T>().convert(item);
-                rb_yield(element);
-              }
-              return self;
-            });
+        klass_.template define_iterator<typename T::iterator(T::*)()>(&T::begin, &T::end);
+      }
+
+      void define_to_array()
+      {
+        // Add enumerable support
+        klass_.define_method("to_a", [](T& vector)
+        {
+          VALUE result = rb_ary_new();
+          std::for_each(vector.begin(), vector.end(), [&result](const Value_T& element)
+          {
+            VALUE value = detail::To_Ruby<Value_T&>().convert(element);
+            rb_ary_push(result, value);
+          });
+
+          return result;
+        }, Return().setValue());
       }
 
       void define_to_s()
       {
         if constexpr (detail::is_ostreamable_v<Value_T>)
         {
-          klass_.define_method("to_s", [](const T& self)
+          klass_.define_method("to_s", [](const T& vector)
             {
-              auto iter = self.begin();
-              auto finish = self.size() > 1000 ? self.begin() + 1000 : self.end();
+              auto iter = vector.begin();
+              auto finish = vector.size() > 1000 ? vector.begin() + 1000 : vector.end();
 
               std::stringstream stream;
               stream << "[";
 
               for (; iter != finish; iter++)
               {
-                if (iter == self.begin())
+                if (iter == vector.begin())
                 {
                   stream << *iter;
                 }
@@ -900,7 +2243,7 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& self)
+          klass_.define_method("to_s", [](const T& vector)
             {
               return "[Not printable]";
             });
@@ -915,9 +2258,13 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_vector_under(Object module, std::string name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
-      return Data_Type<T>(Data_Type<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());
+
+      return Data_Type<T>();
     }
 
     Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(module, name.c_str());
@@ -928,9 +2275,13 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_vector(std::string name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
-      return Data_Type<T>(Data_Type<T>());
+      // 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>();
     }
 
     Data_Type<T> result = define_class<detail::intrinsic_type<T>>(name.c_str());
@@ -956,7 +2307,7 @@ namespace Rice
       {
         Type<T>::verify();
 
-        if (!detail::TypeRegistry::isDefined<std::vector<T>>())
+        if (!detail::Registries::instance.types.isDefined<std::vector<T>>())
         {
           define_vector_auto<std::vector<T>>();
         }
@@ -968,7 +2319,7 @@ namespace Rice
     template<typename T>
     std::vector<T> vectorFromArray(VALUE value)
     {
-      size_t length = protect(rb_array_len, value);
+      long length = protect(rb_array_len, value);
       std::vector<T> result(length);
 
       for (long i = 0; i < length; i++)
@@ -1022,6 +2373,11 @@ namespace Rice
         }
       }
 
+      bool is_convertible(VALUE value)
+      {
+        return rb_type(value) == RUBY_T_ARRAY;
+      }
+
     private:
       Arg* arg_ = nullptr;
     };
@@ -1069,6 +2425,11 @@ namespace Rice
         }
       }
 
+      bool is_convertible(VALUE value)
+      {
+        return rb_type(value) == RUBY_T_ARRAY;
+      }
+
     private:
       Arg* arg_ = nullptr;
       std::vector<T> converted_;
@@ -1104,10 +2465,16 @@ namespace Rice
         }
       }
 
+      bool is_convertible(VALUE value)
+      {
+        return rb_type(value) == RUBY_T_ARRAY;
+      }
+
     private:
       std::vector<T> converted_;
     };
   }
 }
 
+
 #endif // Rice__stl__hpp_