rice 4.3.3 → 4.5.0

data/include/rice/stl.hpp

@@ -2,12 +2,86 @@
 #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_mRice = define_module("Rice");
+    Module rb_mStd = define_module_under(rb_mRice, "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 <functional>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::exception_ptr> define_exception_ptr()
+  {
+    Module rb_mRice = define_module("Rice");
+    Module rb_mStd = define_module_under(rb_mRice, "Std");
+
+    return define_class_under<std::exception_ptr>(rb_mStd, "ExceptionPtr");
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::exception_ptr>
+  {
+    static bool verify()
+    {
+      if (!detail::Registries::instance.types.isDefined<std::exception_ptr>())
+      {
+        stl::define_exception_ptr();
+      }
+
+      return true;
+    }
+  };
+}
+
+
 // =========   string.hpp   =========
 
 
 // ---------   string.ipp   ---------
-#include <string>
-
 namespace Rice::detail
 {
   template<>
@@ -49,9 +123,16 @@ 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)
@@ -81,9 +162,16 @@ 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)
@@ -109,9 +197,16 @@ namespace Rice::detail
   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)
@@ -129,9 +224,16 @@ namespace Rice::detail
   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,9 +295,16 @@ 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)
@@ -251,6 +360,18 @@ namespace Rice::detail
   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 +379,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 +406,6 @@ namespace Rice::detail
       return this->converted_;
     }
 
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_COMPLEX;
-    }
-
   private:
     std::complex<T> converted_;
   };
@@ -354,6 +477,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 +506,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 +530,6 @@ namespace Rice::detail
       }
       return this->converted_;
     }
-    
   private:
     std::optional<T> converted_;
   };
@@ -421,9 +567,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)
@@ -494,12 +640,11 @@ namespace Rice::detail
   class To_Ruby<std::unique_ptr<T>>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
+
     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);
     }
   };
@@ -508,26 +653,84 @@ namespace Rice::detail
   class To_Ruby<std::unique_ptr<T>&>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
+
     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 From_Ruby<std::unique_ptr<T>>
+  {
+  public:
+    using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
+
+    Wrapper_T* is_same_smart_ptr(VALUE value)
+    {
+      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper_T*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::unique_ptr<T> convert(VALUE value)
+    {
+      Wrapper_T* smartWrapper = is_same_smart_ptr(value);
+      if (!smartWrapper)
+      {
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
+      }
+      return std::move(smartWrapper->data());
+    }
+  };
+
   template <typename T>
   class From_Ruby<std::unique_ptr<T>&>
   {
   public:
-    std::unique_ptr<T>& convert(VALUE value)
+    using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
+
+    Wrapper_T* is_same_smart_ptr(VALUE value)
     {
       Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper_T*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
 
-      using Wrapper_T = WrapperSmartPointer<std::unique_ptr, T>;
-      Wrapper_T* smartWrapper = dynamic_cast<Wrapper_T*>(wrapper);
+    std::unique_ptr<T>& convert(VALUE value)
+    {
+      Wrapper_T* smartWrapper = is_same_smart_ptr(value);
       if (!smartWrapper)
       {
         std::string message = "Invalid smart pointer wrapper";
@@ -551,36 +754,68 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
+
     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 <>
+  class To_Ruby<std::shared_ptr<void>>
+  {
+  public:
+    using Wrapper_T = WrapperSmartPointer<std::shared_ptr, void>;
+
+    VALUE convert(std::shared_ptr<void>& data)
+    {
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(data.get());
+      return detail::wrap<std::shared_ptr<void>, Wrapper_T>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+  };
+
   template <typename T>
   class From_Ruby<std::shared_ptr<T>>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg * arg) : arg_(arg)
     {
     }
 
+    Wrapper_T* is_same_smart_ptr(VALUE value)
+    {
+      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper_T*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
     std::shared_ptr<T> convert(VALUE value)
     {
       if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
         return this->arg_->template defaultValue<std::shared_ptr<T>>();
       }
 
-      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);
+      Wrapper_T* smartWrapper = is_same_smart_ptr(value);
       if (!smartWrapper)
       {
         std::string message = "Invalid smart pointer wrapper";
@@ -588,7 +823,6 @@ namespace Rice::detail
       }
       return smartWrapper->data();
     }
-
   private:
     Arg* arg_ = nullptr;
   };
@@ -597,12 +831,11 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>&>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
+
     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);
     }
   };
@@ -611,22 +844,42 @@ namespace Rice::detail
   class From_Ruby<std::shared_ptr<T>&>
   {
   public:
+    using Wrapper_T = WrapperSmartPointer<std::shared_ptr, T>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg * arg) : arg_(arg)
     {
     }
 
+    Wrapper_T* is_same_smart_ptr(VALUE value)
+    {
+      Wrapper* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper_T*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
     std::shared_ptr<T>& convert(VALUE value)
     {
       if(value == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
         return this->arg_->template defaultValue<std::shared_ptr<T>>();
       }
 
-      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);
+      Wrapper_T* smartWrapper = is_same_smart_ptr(value);
       if (!smartWrapper)
       {
         std::string message = "Invalid smart pointer wrapper";
@@ -691,9 +944,9 @@ namespace Rice::detail
   class From_Ruby<std::monostate>
   {
   public:
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return false;
+      return Convertible::None;
     }
 
     std::monostate convert(VALUE value)
@@ -706,9 +959,9 @@ namespace Rice::detail
   class From_Ruby<std::monostate&>
   {
   public:
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return false;
+      return Convertible::None;
     }
 
     std::monostate& convert(VALUE value)
@@ -722,6 +975,81 @@ namespace Rice::detail
 }
 
 
+// =========   type_index.hpp   =========
+
+
+// ---------   type_index.ipp   ---------
+#include <typeindex>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::type_index> define_type_index()
+  {
+    Module rb_mRice = define_module("Rice");
+    Module rb_mStd = define_module_under(rb_mRice, "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 Rice::detail
+{
+  template<>
+  struct Type<std::type_index>
+  {
+    static bool verify()
+    {
+      if (!detail::Registries::instance.types.isDefined<std::type_index>())
+      {
+        stl::define_type_index();
+      }
+
+      return true;
+    }
+  };
+}
+
+
+// =========   type_info.hpp   =========
+
+
+// ---------   type_info.ipp   ---------
+#include <typeinfo>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::type_info> define_type_info()
+  {
+    Module rb_mRice = define_module("Rice");
+    Module rb_mStd = define_module_under(rb_mRice, "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();
+      }
+
+      return true;
+    }
+  };
+}
+
+
 // =========   variant.hpp   =========
 
 
@@ -781,14 +1109,24 @@ namespace Rice::detail
         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
+        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/ */
 
       VALUE result = Qnil;
+
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wunused-value"
+      #endif
+
       ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
                (result = convertElement<std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
+      
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic pop
+      #endif
 
       return result;
     }
@@ -818,9 +1156,19 @@ namespace Rice::detail
 
       // See comments above for explanation of this code
       VALUE result = Qnil;
+
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wunused-value"
+      #endif
+
       ((std::holds_alternative<std::tuple_element_t<I, Tuple_T>>(data) ?
         (result = convertElement<std::tuple_element_t<I, Tuple_T>>(data, takeOwnership), true) : false) || ...);
 
+      #if defined(__GNUC__) || defined(__clang__)
+      #pragma GCC diagnostic pop
+      #endif
+
       return result;
     }
 
@@ -834,83 +1182,102 @@ namespace Rice::detail
   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:
+    Convertible is_convertible(VALUE value)
+    {
+      Convertible result = Convertible::None;
+
+      for_each_tuple(this->fromRubys_,
+        [&](auto& fromRuby)
+        {
+          result = result | fromRuby.is_convertible(value);
+        });
+
+      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)
+        {
+          Convertible isConvertible = fromRuby.is_convertible(value);
+
+          if (isConvertible > foundConversion)
+          {
+            index = i;
+            foundConversion = isConvertible;
+          }
+          i++;
+        });
+
+      if (index == -1)
+      {
+        rb_raise(rb_eArgError, "Could not find converter for variant");
+      }
+
+      return index;
+    }
+
     /* 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). 
+       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. 
-       
+       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)
+    std::variant<Types...> convertInternal(VALUE value, int index)
     {
-      // 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))
+        if (I == index)
         {
-          return converter.convert(value);
+          auto fromRuby = std::get<I>(this->fromRubys_);
+          return fromRuby.convert(value);
         }
         else
         {
-          return convertInternal<I + 1>(value);
+          return convertInternal<I + 1>(value, index);
         }
       }
-      throw std::runtime_error("Could not find converter for variant");
+      rb_raise(rb_eArgError, "Could not find converter for variant");
     }
 
     std::variant<Types...> convert(VALUE value)
     {
-      return convertInternal(value);
+      int index = this->figureIndex(value);
+      return this->convertInternal(value, index);
     }
-  };
 
-  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>...>;
+    From_Ruby_Ts fromRubys_;
+  };
 
+  template<typename...Types>
+  class From_Ruby<std::variant<Types...>&> : public From_Ruby<std::variant<Types...>>
+  {
   public:
-    template <std::size_t I = 0>
-    std::variant<Types...> convertInternal(VALUE value)
+    std::variant<Types...>& convert(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");
+      int index = this->figureIndex(value);
+      this->converted_ = this->convertInternal(value, index);
+      return this->converted_;
     }
 
-    std::variant<Types...> convert(VALUE value)
-    {
-      return convertInternal(value);
-    }
+  private:
+    std::variant<Types...> converted_;
   };
 }
 
@@ -924,7 +1291,7 @@ namespace Rice
   Data_Type<T> define_pair(std::string name);
 
   template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name);
+  Data_Type<T> define_pair_under(Object parent, std::string name);
 }
 
 
@@ -1044,17 +1411,17 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_pair_under(Object module, std::string name)
+  Data_Type<T> define_pair_under(Object parent, 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());
+      parent.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());
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(parent, name.c_str());
     stl::PairHelper helper(result);
     return result;
   }
@@ -1078,10 +1445,11 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_pair_auto()
   {
-    std::string klassName = detail::makeClassName(typeid(T));
+    std::string name = detail::typeName(typeid(T));
+    std::string klassName = detail::makeClassName(name);
     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_under(rb_mRice, "Std");
+    return define_pair_under<T>(rb_mStd, klassName);
   }
    
   namespace detail
@@ -1138,8 +1506,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:
       MapHelper(Data_Type<T> klass) : klass_(klass)
@@ -1288,7 +1658,7 @@ namespace Rice
                 return std::nullopt;
               }
             })
-          .define_method("[]=", [](T& map, Key_T key, Mapped_T value) -> Mapped_T
+          .define_method("[]=", [](T& map, Key_T key, Mapped_T& value) -> Mapped_T
             {
               map[key] = value;
               return value;
@@ -1309,10 +1679,10 @@ namespace Rice
         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)
+          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<Mapped_T&>().convert(pair.second);
+            VALUE value = detail::To_Ruby<To_Ruby_T&>().convert(pair.second);
             rb_hash_aset(result, key, value);
           });
 
@@ -1359,17 +1729,17 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_map_under(Object module, std::string name)
+  Data_Type<T> define_map_under(Object parent, 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());
+      parent.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());
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(parent, name.c_str());
     stl::MapHelper helper(result);
     return result;
   }
@@ -1393,10 +1763,11 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_map_auto()
   {
-    std::string klassName = detail::makeClassName(typeid(T));
+    std::string name = detail::typeName(typeid(T));
+    std::string klassName = detail::makeClassName(name);
     Module rb_mRice = define_module("Rice");
-    Module rb_mmap = define_module_under(rb_mRice, "Std");
-    return define_map_under<T>(rb_mmap, klassName);
+    Module rb_mStd = define_module_under(rb_mRice, "Std");
+    return define_map_under<T>(rb_mStd, klassName);
   }
    
   namespace detail
@@ -1457,16 +1828,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            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 T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped map (hopefully!)
             return *Data_Object<std::map<T, U>>::from_ruby(value);
           }
-          case T_HASH:
+          case RUBY_T_HASH:
           {
             // If this an Ruby hash and the mapped type is copyable
             if constexpr (std::is_default_constructible_v<U>)
@@ -1474,7 +1860,7 @@ namespace Rice
               return MapFromHash<T, U>::convert(value);
             }
           }
-          case T_NIL:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -1503,16 +1889,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            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 T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped map (hopefully!)
             return *Data_Object<std::map<T, U>>::from_ruby(value);
           }
-          case T_HASH:
+          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>>)
@@ -1521,7 +1922,7 @@ namespace Rice
               return this->converted_;
             }
           }
-          case T_NIL:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -1545,16 +1946,34 @@ namespace Rice
     class From_Ruby<std::map<T, U>*>
     {
     public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Convertible::Exact;
+            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 T_DATA:
+          case RUBY_T_DATA:
           {
             // This is a wrapped map (hopefully!)
             return Data_Object<std::map<T, U>>::from_ruby(value);
           }
-          case T_HASH:
+          case RUBY_T_HASH:
           {
             // If this an Ruby array and the map type is copyable
             if constexpr (std::is_default_constructible_v<U>)
@@ -1586,7 +2005,7 @@ namespace Rice
   Data_Type<U> define_unordered_map(std::string name);
 
   template<typename U>
-  Data_Type<U> define_unordered_map_under(Object module, std::string name);
+  Data_Type<U> define_unordered_map_under(Object parent, std::string name);
 }
 
 
@@ -1608,8 +2027,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)
@@ -1758,7 +2179,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 +2200,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);
           });
 
@@ -1829,17 +2250,17 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_unordered_map_under(Object module, std::string name)
+  Data_Type<T> define_unordered_map_under(Object parent, std::string name)
   {
     if (detail::Registries::instance.types.isDefined<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());
+      parent.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());
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(parent, name.c_str());
     stl::UnorderedMapHelper helper(result);
     return result;
   }
@@ -1863,10 +2284,11 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_unordered_map_auto()
   {
-    std::string klassName = detail::makeClassName(typeid(T));
+    std::string name = detail::typeName(typeid(T));
+    std::string klassName = detail::makeClassName(name);
     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);
+    Module rb_mStd = define_module_under(rb_mRice, "Std");
+    return define_unordered_map_under<T>(rb_mStd, klassName);
   }
    
   namespace detail
@@ -1927,16 +2349,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            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);
           }
-          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,7 +2381,7 @@ namespace Rice
               return UnorderedMapFromHash<T, U>::convert(value);
             }
           }
-          case T_NIL:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -1973,16 +2410,31 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            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);
           }
-          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,7 +2443,7 @@ namespace Rice
               return this->converted_;
             }
           }
-          case T_NIL:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -2015,16 +2467,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 Convertible::Exact;
+            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);
           }
-          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>)
@@ -2056,7 +2526,7 @@ namespace Rice
   Data_Type<T> define_vector(std::string name);
 
   template<typename T>
-  Data_Type<T> define_vector_under(Object module, std::string name);
+  Data_Type<T> define_vector_under(Object parent, std::string name);
 }
 
 
@@ -2075,9 +2545,17 @@ 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)
@@ -2141,7 +2619,11 @@ namespace Rice
 
       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,41 +2654,71 @@ 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
+              if (start + length > vector.size())
               {
-                return std::nullopt;
+                length = vector.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());
+
+          rb_define_alias(klass_, "at", "[]");
       }
 
       // Methods that require Value_T to support operator==
@@ -2214,7 +2726,7 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Value_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 +2740,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 +2759,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 +2784,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,13 +2804,13 @@ 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;
@@ -2321,9 +2833,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,18 +2886,19 @@ namespace Rice
   } // namespace
 
   template<typename T>
-  Data_Type<T> define_vector_under(Object module, std::string name)
+  Data_Type<T> define_vector_under(Object parent, std::string name)
   {
     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());
+      parent.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());
+    Identifier id(name);
+    Data_Type<T> result = define_class_under<detail::intrinsic_type<T>>(parent, id, rb_cObject);
     stl::VectorHelper helper(result);
     return result;
   }
@@ -2410,10 +2923,11 @@ namespace Rice
   template<typename T>
   Data_Type<T> define_vector_auto()
   {
-    std::string klassName = detail::makeClassName(typeid(T));
+    std::string name = detail::typeName(typeid(T));
+    std::string klassName = detail::makeClassName(name);
     Module rb_mRice = define_module("Rice");
-    Module rb_mVector = define_module_under(rb_mRice, "Std");
-    return define_vector_under<T>(rb_mVector, klassName);
+    Module rb_mStd = define_module_under(rb_mRice, "Std");
+    return define_vector_under<T>(rb_mStd, klassName);
   }
    
   namespace detail
@@ -2434,20 +2948,6 @@ namespace Rice
       }
     };
 
-    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,24 +2959,39 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_ARRAY:
+            return Convertible::Cast;
+            break;
+          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);
           }
-          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);
+              return Array(value).to_vector<T>();
             }
           }
-          case T_NIL:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -2491,11 +3006,6 @@ namespace Rice
         }
       }
 
-      bool is_convertible(VALUE value)
-      {
-        return rb_type(value) == RUBY_T_ARRAY;
-      }
-
     private:
       Arg* arg_ = nullptr;
     };
@@ -2510,25 +3020,40 @@ namespace Rice
       {
       }
 
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_ARRAY:
+            return Convertible::Cast;
+            break;
+          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);
           }
-          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:
+          case RUBY_T_NIL:
           {
             if (this->arg_ && this->arg_->hasDefaultValue())
             {
@@ -2543,11 +3068,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 +3077,39 @@ namespace Rice
     class From_Ruby<std::vector<T>*>
     {
     public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_ARRAY:
+            return Convertible::Cast;
+            break;
+          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);
           }
-          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 +3121,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;
+      }
+    };
+  }
 }