rice 4.7.1 → 4.9.0

data/include/rice/stl.hpp

@@ -1,3 +1,30 @@
+// This file is part of [rice](https://github.com/ruby-rice/rice).
+//
+// Copyright (C) 2025 Jason Roelofs <jasongroelofs@gmail.com>
+//                    Paul Brannan <curlypaul924@gmail.com>,
+//                    Charlie Savage
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 #ifndef Rice__stl__hpp_
 #define Rice__stl__hpp_
 
@@ -162,7 +189,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -172,7 +199,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -181,7 +208,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -191,7 +218,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<int N>
@@ -200,7 +227,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -211,7 +238,7 @@ namespace Rice::detail
       return dataObject.value();
     }
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -220,14 +247,14 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     VALUE convert(const std::string* value)
     {
-      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-      bool isBuffer = this->returnInfo_ && this->returnInfo_->isBuffer();
+      bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = dynamic_cast<ReturnBuffer*>(this->arg_) ? true : false;
 
       if (isBuffer)
       {
@@ -241,7 +268,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -250,7 +277,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -260,7 +287,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   /*template<>
@@ -269,7 +296,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -281,7 +308,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };*/
 
   template<>
@@ -294,7 +321,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -326,7 +353,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -360,7 +387,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -394,7 +421,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -489,7 +516,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -540,7 +567,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -553,7 +580,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -562,7 +589,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -575,7 +602,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -584,11 +611,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) :arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -607,6 +634,9 @@ namespace Rice::detail
 
       return std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -615,11 +645,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -641,6 +671,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::complex<T> converted_;
   };
 }
@@ -715,17 +746,17 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::nullopt_t& _)
+    VALUE convert(const std::nullopt_t&)
     {
       return Qnil;
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -734,7 +765,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -750,8 +781,20 @@ namespace Rice::detail
       }
     }
 
+    VALUE convert(const std::optional<T>& data)
+    {
+      if (data.has_value())
+      {
+        return To_Ruby<T>().convert(data.value());
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -760,7 +803,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -777,7 +820,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -786,11 +829,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -813,6 +856,9 @@ namespace Rice::detail
         return From_Ruby<T>().convert(value);
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -821,11 +867,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -850,6 +896,7 @@ namespace Rice::detail
       return this->converted_;
     }
   private:
+    Arg* arg_ = nullptr;
     std::optional<T> converted_;
   };
 }
@@ -884,7 +931,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -894,7 +941,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -903,11 +950,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return this->converter_.is_convertible(value);
     }
@@ -918,6 +965,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     From_Ruby<T&> converter_;
   };
 }
@@ -997,11 +1045,11 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& pair)
-            {
-              return "[Not printable]";
-            });
-        }
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
+      }
       }
 
       private:
@@ -1175,20 +1223,25 @@ namespace Rice
       {
         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;
-                });
+          klass_.define_method("==", [](T& map, T& other)->bool
+          {
+            return map == other;
+          })
+          .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();
+            return it != map.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -1273,10 +1326,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& map)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -1367,7 +1420,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -1375,7 +1428,7 @@ namespace Rice
             return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -1401,7 +1454,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }
@@ -1421,7 +1474,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -1429,7 +1482,7 @@ namespace Rice
             return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -1456,7 +1509,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }
@@ -1477,7 +1530,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -1488,7 +1541,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -1515,7 +1568,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }
@@ -1556,18 +1609,18 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::monostate& _)
+    VALUE convert(const std::monostate&)
     {
       return Qnil;
     }
 
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -1576,17 +1629,17 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::monostate& data)
+    VALUE convert(const std::monostate&)
     {
       return Qnil;
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -1595,13 +1648,13 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      return value == Qnil ? Convertible::Exact : Convertible::None;
+      return value == Qnil ? 1.0 : 0.0;
     }
 
     std::monostate convert(VALUE value)
@@ -1615,6 +1668,9 @@ namespace Rice::detail
         throw std::runtime_error("Can only convert nil values to std::monostate");
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -1623,13 +1679,13 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      return value == Qnil ? Convertible::Exact : Convertible::None;
+      return value == Qnil ? 1.0 : 0.0;
     }
 
     std::monostate& convert(VALUE value)
@@ -1645,6 +1701,7 @@ namespace Rice::detail
     }
     
   private:
+    Arg* arg_ = nullptr;
     std::monostate converted_ = std::monostate();
   };
 }
@@ -1652,8 +1709,6 @@ namespace Rice::detail
 
 // =========   multimap.hpp   =========
 
-#include <map>
-
 namespace Rice
 {
   template<typename K, typename T>
@@ -1770,20 +1825,25 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Mapped_T>)
         {
-          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
-            {
-              auto it = std::find_if(multimap.begin(), multimap.end(),
-              [&value](auto& pair)
-                {
-                  return pair.second == value;
-                });
+          klass_.define_method("==", [](T& multimap, T& other)->bool
+          {
+            return multimap == other;
+          })
+          .define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          {
+            auto it = std::find_if(multimap.begin(), multimap.end(),
+            [&value](auto& pair)
+              {
+                return pair.second == value;
+              });
 
-              return it != multimap.end();
+            return it != multimap.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -1852,10 +1912,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& multimap)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -1943,7 +2003,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -1951,7 +2011,7 @@ namespace Rice
             return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -1977,7 +2037,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }
@@ -1997,7 +2057,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -2005,7 +2065,7 @@ namespace Rice
             return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -2032,7 +2092,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }
@@ -2053,7 +2113,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -2064,7 +2124,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -2091,7 +2151,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }
@@ -2333,10 +2393,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& self)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -2423,7 +2483,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -2435,7 +2495,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -2459,12 +2519,12 @@ namespace Rice
             {
               return toSet<T>(value);
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }
@@ -2487,7 +2547,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -2499,7 +2559,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -2528,12 +2588,12 @@ namespace Rice
                 return this->converted_;
               }
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }
@@ -2556,7 +2616,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -2571,7 +2631,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -2600,12 +2660,12 @@ namespace Rice
                 return &this->converted_;
               }
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }
@@ -2621,33 +2681,32 @@ namespace Rice
 
 // =========   shared_ptr.hpp   =========
 
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
+}
+
 namespace Rice::detail
 {
   template<typename T>
   class Wrapper<std::shared_ptr<T>> : public WrapperBase
   {
   public:
-    Wrapper(const std::shared_ptr<T>& data);
+    Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data);
     ~Wrapper();
-    void* get() override;
-    std::shared_ptr<T>& data();
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     std::shared_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
   };
 }
 
-namespace Rice
-{
-  template<typename T>
-  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
-}
-
 
 // ---------   shared_ptr.ipp   ---------
 #include <memory>
 
-// --------- Enable creation of std::shared_ptr from Ruby ---------
 namespace Rice
 {
   template<typename T>
@@ -2670,7 +2729,24 @@ namespace Rice
 
     Identifier id(klassName);
     Data_Type_T result = define_class_under<detail::intrinsic_type<SharedPtr_T>>(rb_mStd, id).
-      define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      define_method("get", &SharedPtr_T::get).
+      define_method("swap", &SharedPtr_T::swap).
+      define_method("use_count", &SharedPtr_T::use_count).
+      define_method("empty?", [](SharedPtr_T& self)->bool
+      {
+        return !self;
+      });
+
+    if constexpr (!std::is_void_v<T>)
+    {
+      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+    }
+
+    // Setup delegation to forward T's methods via get (only for non-fundamental, non-void types)
+    if constexpr (!std::is_void_v<T> && !std::is_fundamental_v<T>)
+    {
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
+    }
 
     return result;
   }
@@ -2680,31 +2756,47 @@ namespace Rice
 namespace Rice::detail
 {
   template<typename T>
-  inline Wrapper<std::shared_ptr<T>>::Wrapper(const std::shared_ptr<T>& data)
-    : data_(data)
+  Wrapper<std::shared_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data)
+    : WrapperBase(rb_data_type), data_(data)
   {
-  }
+    using Intrinsic_T = intrinsic_type<T>;
 
-  template<typename T>
-  inline Wrapper<std::shared_ptr<T>>::~Wrapper()
-  {
-    Registries::instance.instances.remove(this->get());
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
+    {
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
+    }
+    else
+    {
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
+    }
   }
 
   template<typename T>
-  inline void* Wrapper<std::shared_ptr<T>>::get()
+  Wrapper<std::shared_ptr<T>>::~Wrapper()
   {
-    return (void*)this->data_.get();
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template<typename T>
-  inline std::shared_ptr<T>& Wrapper<std::shared_ptr<T>>::data()
+  void* Wrapper<std::shared_ptr<T>>::get(rb_data_type_t* requestedType)
   {
-    return data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return &this->data_;
+    }
+    else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
+    {
+      return this->data_.get();
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type (expected %s)",
+          requestedType->wrap_struct_name);
+    }
   }
 }
 
-// --------- Type/To_Ruby/From_Ruby ---------
+// --------- Type ---------
 namespace Rice::detail
 {
   template<typename T>
@@ -2712,188 +2804,23 @@ namespace Rice::detail
   {
     static bool verify()
     {
+      bool result = true;
       if constexpr (std::is_fundamental_v<T>)
       {
-        return Type<Pointer<T>>::verify();
-        return Type<Buffer<T>>::verify();
-      }
-      else
-      {
-        return Type<T>::verify();
-      }
-    }
-
-    static VALUE rubyKlass()
-    {
-      if (Data_Type<std::shared_ptr<T>>::is_defined())
-      {
-        std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<std::shared_ptr<T>>();
-        return pair.first;
-      }
-      else
-      {
-        TypeMapper<T> typeMapper;
-        return typeMapper.rubyKlass();
-      }
-    }
-  };
-
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>>
-  {
-  public:
-    To_Ruby() = default;
-
-    explicit To_Ruby(Arg* arv)
-    {
-    }
-
-    VALUE convert(std::shared_ptr<T>& data)
-    {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
+        result = result && Type<Pointer<T>>::verify();
       }
       else
       {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        result = result && Type<T>::verify();
       }
-    }
-
-    VALUE convert(std::shared_ptr<T>&& data)
-    {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
-      }
-      else
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-      }
-    }
-  };
-
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
-      }
-    }
-
-    std::shared_ptr<T> convert(VALUE value)
-    {
-      // Get the wrapper
-      WrapperBase* wrapperBase = detail::getWrapper(value);
-
-      // Was this shared_ptr created by the user from Ruby? If so it will
-      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
-      // return the shared pointer
-      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
-      {
-        // Use unwrap to validate the underlying wrapper is the correct type
-        std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
-        return *ptr;
-      }
-      else if (std::is_fundamental_v<T>)
-      {
-        // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
-        return wrapper->data();
-      }
-      else
-      {
-        // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
-        return wrapper->data();
-      }
-    }
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    To_Ruby() = default;
-
-    explicit To_Ruby(Arg* arg)
-    {
-    }
-
-    VALUE convert(std::shared_ptr<T>& data)
-    {
-      return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-    }
-  };
-
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    From_Ruby() = default;
 
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
+      if (result)
       {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
+        define_shared_ptr<T>();
       }
-    }
 
-    std::shared_ptr<T>& convert(VALUE value)
-    {
-      // Get the wrapper
-      WrapperBase* wrapperBase = detail::getWrapper(value);
-
-      // Was this shared_ptr created by the user from Ruby? If so it will
-      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
-      // return the shared pointer
-      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
-      {
-        // Use unwrap to validate the underlying wrapper is the correct type
-        std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
-        return *ptr;
-      }
-      else if (std::is_fundamental_v<T>)
-      {
-        // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
-        return wrapper->data();
-      }
-      else
-      {
-        // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
-        return wrapper->data();
-      }
+      return result;
     }
-
-  private:
-    Arg* arg_ = nullptr;
   };
 }
 
@@ -2912,7 +2839,7 @@ namespace Rice::detail
     using Tuple_T = std::tuple<Types...>;
 
     template<std::size_t... I>
-    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    constexpr static bool verifyTypes(std::index_sequence<I...>&)
     {
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
@@ -2936,7 +2863,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -2953,7 +2880,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -2962,7 +2889,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -2970,7 +2897,7 @@ namespace Rice::detail
     {
       Array result;
 
-      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
+      bool isOwner = (this->arg_ && this->arg_->isOwner());
 
       for_each_tuple(data, [&](auto& element)
       {
@@ -2981,7 +2908,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -2990,35 +2917,28 @@ namespace Rice::detail
   public:
     using Tuple_T = std::tuple<Types...>;
 
-    template<std::size_t... I>
-    constexpr static bool verifyTypes(Array& array, std::index_sequence<I...>& indices)
-    {
-      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
-    }
-
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      Convertible result = Convertible::None;
-
       // The ruby value must be an array of the correct size
       if (rb_type(value) != RUBY_T_ARRAY || Array(value).size() != std::tuple_size_v<Tuple_T>)
       {
-        return result;
+        return Convertible::None;
       }
-      
-      // Now check that each tuple type is convertible
+
+      // Now check that each tuple type is convertible - use minimum score
+      double result = Convertible::Exact;
       Array array(value);
       int i = 0;
       for_each_tuple(this->fromRubys_,
         [&](auto& fromRuby)
         {
-          result = result | fromRuby.is_convertible(array[i].value());
+          result = (std::min)(result, fromRuby.is_convertible(array[i].value()));
           i++;
         });
 
@@ -3026,7 +2946,7 @@ namespace Rice::detail
     }
 
     template <std::size_t... I>
-    std::tuple<Types...> convertInternal(Array array, std::index_sequence<I...>& indices)
+    std::tuple<Types...> convertInternal(Array array, std::index_sequence<I...>&)
     {
       return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(array[I].value())...);
     }
@@ -3039,25 +2959,11 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     // 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::tuple<Types...>&> : public From_Ruby<std::tuple<Types...>>
-  {
-  public:
-    std::tuple<Types...>& convert(VALUE value)
-    {
-      int index = this->figureIndex(value);
-      this->converted_ = this->convertInternal(value, index);
-      return this->converted_;
-    }
-
-  private:
-    std::tuple<Types...> converted_;
-  };*/
 }
 
 
@@ -3146,7 +3052,7 @@ namespace Rice::detail
     using Tuple_T = std::tuple<Types...>;
 
     template<std::size_t... I>
-    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    constexpr static bool verifyTypes(std::index_sequence<I...>&)
     {
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
@@ -3170,18 +3076,23 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U, typename V>
     VALUE convertElement(U& data, bool takeOwnership)
     {
-      return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+      Arg arg("arg1");
+      if (takeOwnership)
+      {
+        arg.takeOwnership();
+      }
+      return To_Ruby<V>(&arg).convert(std::forward<V>(std::get<V>(data)));
     }
 
     template<typename U, std::size_t... I>
-    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>&)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -3239,7 +3150,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -3248,25 +3159,31 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U, typename V>
     VALUE convertElement(U& data, bool takeOwnership)
     {
+      Arg arg("arg1");
+      if (takeOwnership)
+      {
+        arg.takeOwnership();
+      }
+
       if constexpr (std::is_const_v<U>)
       {
-        return To_Ruby<V>().convert(std::get<V>(data));
+        return To_Ruby<V>(&arg).convert(std::get<V>(data));
       }
       else
       {
-        return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+        return To_Ruby<V>(&arg).convert(std::forward<V>(std::get<V>(data)));
       }
     }
 
     template<typename U, std::size_t... I>
-    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>&)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -3292,13 +3209,13 @@ namespace Rice::detail
     template<typename U>
     VALUE convert(U& data)
     {
-      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
+      bool isOwner = (this->arg_ && this->arg_->isOwner());
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
       return convertIterator(data, isOwner, indices);
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -3307,18 +3224,18 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      Convertible result = Convertible::None;
+      double result = Convertible::None;
 
       for_each_tuple(this->fromRubys_,
         [&](auto& fromRuby)
         {
-          result = result | fromRuby.is_convertible(value);
+          result = (std::max)(result, fromRuby.is_convertible(value));
         });
 
       return result;
@@ -3330,17 +3247,17 @@ namespace Rice::detail
     {
       int i = 0;
       int index = -1;
-      Convertible foundConversion = Convertible::None;
+      double foundScore = Convertible::None;
 
       for_each_tuple(this->fromRubys_,
         [&](auto& fromRuby)
         {
-          Convertible isConvertible = fromRuby.is_convertible(value);
+          double score = fromRuby.is_convertible(value);
 
-          if (isConvertible > foundConversion)
+          if (score > foundScore)
           {
             index = i;
-            foundConversion = isConvertible;
+            foundScore = score;
           }
           i++;
         });
@@ -3378,7 +3295,10 @@ namespace Rice::detail
           return convertInternal<I + 1>(value, index);
         }
       }
-      rb_raise(rb_eArgError, "Could not find converter for variant");
+      else
+      {
+        rb_raise(rb_eArgError, "Could not find converter for variant");
+      }
     }
 
     std::variant<Types...> convert(VALUE value)
@@ -3388,6 +3308,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     // Possible converters we could use for this variant
     using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
     From_Ruby_Ts fromRubys_;
@@ -3399,7 +3320,7 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -3411,6 +3332,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::variant<Types...> converted_;
   };
 }
@@ -3418,19 +3340,25 @@ namespace Rice::detail
 
 // =========   unique_ptr.hpp   =========
 
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName = "");
+}
+
 namespace Rice::detail
 {
   template<typename T>
   class Wrapper<std::unique_ptr<T>> : public WrapperBase
   {
   public:
-    Wrapper(std::unique_ptr<T>&& data);
+    Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data);
     ~Wrapper();
-    void* get() override;
-    std::unique_ptr<T>& data();
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     std::unique_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
   };
 }
 
@@ -3438,142 +3366,132 @@ namespace Rice::detail
 // ---------   unique_ptr.ipp   ---------
 #include <memory>
 
-namespace Rice::detail
+namespace Rice
 {
   template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::Wrapper(std::unique_ptr<T>&& data)
-    : data_(std::move(data))
-  {
-  }
-
-  template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::~Wrapper()
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName)
   {
-    Registries::instance.instances.remove(this->get());
-  }
+    using UniquePtr_T = std::unique_ptr<T>;
+    using Data_Type_T = Data_Type<UniquePtr_T>;
 
-  template<typename T>
-  inline void* Wrapper<std::unique_ptr<T>>::get()
-  {
-    return (void*)this->data_.get();
-  }
-
-  template<typename T>
-  inline std::unique_ptr<T>& Wrapper<std::unique_ptr<T>>::data()
-  {
-    return data_;
-  }
-
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>>
-  {
-  public:
-    To_Ruby() = default;
-
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    if (klassName.empty())
     {
+      detail::TypeMapper<UniquePtr_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
-    VALUE convert(std::unique_ptr<T>& data)
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      return Data_Type_T();
     }
 
-    VALUE convert(std::unique_ptr<T>&& data)
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<UniquePtr_T>>(rb_mStd, id).
+      define_method("get", &UniquePtr_T::get).
+      define_method("release", &UniquePtr_T::release).
+      define_method("reset", &UniquePtr_T::reset).
+      define_method("swap", &UniquePtr_T::swap).
+      define_method("empty?", [](UniquePtr_T& self)->bool
+      {
+        return !self;
+      });
+
+    // Setup delegation to forward T's methods via get (only for non-fundamental, non-void types)
+    if constexpr (!std::is_void_v<T> && !std::is_fundamental_v<T>)
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
     }
 
-  private:
-    Return* returnInfo_ = nullptr;
-  };
+    return result;
+  }
+}
 
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>&>
+// --------- Wrapper ---------
+namespace Rice::detail
+{
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data)
+    : WrapperBase(rb_data_type), data_(std::move(data))
   {
-  public:
-    To_Ruby() = default;
+    using Intrinsic_T = intrinsic_type<T>;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
     {
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
     }
-
-    VALUE convert(std::unique_ptr<T>& data)
+    else
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
     }
+  }
 
-  private:
-    Return* returnInfo_ = nullptr;
-  };
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+  }
 
-  template <typename T>
-  class From_Ruby<std::unique_ptr<T>>
+  template<typename T>
+  void* Wrapper<std::unique_ptr<T>>::get(rb_data_type_t* requestedType)
   {
-  public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
     {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+      return &this->data_;
     }
-
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg)
+    else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
+      return this->data_.get();
     }
-
-    Convertible is_convertible(VALUE value)
+    else
     {
-      if (!is_same_smart_ptr(value))
-        return Convertible::None;
+      throw Exception(rb_eTypeError, "wrong argument type (expected %s)",
+          requestedType->wrap_struct_name);
+    }
+  }
 
-      switch (rb_type(value))
+}
+
+// --------- Type ---------
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
+    {
+      bool result = true;
+      if constexpr (std::is_fundamental_v<T>)
       {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
+        result = result && Type<Pointer<T>>::verify();
+      }
+      else
+      {
+        result = result && Type<T>::verify();
       }
-    }
 
-    std::unique_ptr<T> convert(VALUE value)
-    {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
+      if (result)
       {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
+        define_unique_ptr<T>();
       }
-      return std::move(wrapper->data());
+
+      return result;
     }
   };
 
+  // --------- From_Ruby ---------
   template <typename T>
-  class From_Ruby<std::unique_ptr<T>&>
+  class From_Ruby<std::unique_ptr<T>>
   {
   public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
-    {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
-    }
-
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      if (!is_same_smart_ptr(value))
-        return Convertible::None;
-
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
@@ -3584,39 +3502,15 @@ namespace Rice::detail
       }
     }
 
-    std::unique_ptr<T>& convert(VALUE value)
-    {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
-      {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
-      }
-      return wrapper->data();
-    }
-  };
-
-  template<typename T>
-  struct Type<std::unique_ptr<T>>
-  {
-    static bool verify()
+    std::unique_ptr<T> convert(VALUE value)
     {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return Type<Pointer<T>>::verify();
-        return Type<Buffer<T>>::verify();
-      }
-      else
-      {
-        return Type<T>::verify();
-      }
+      std::unique_ptr<T>* result = detail::unwrap<std::unique_ptr<T>>(value, Data_Type<std::unique_ptr<T>>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+      // The reason we need this overriden From_Ruby is to do this std::move.
+      return std::move(*result);
     }
 
-    static VALUE rubyKlass()
-    {
-      TypeMapper<T> typeMapper;
-      return typeMapper.rubyKlass();
-    }
+  private:
+    Arg* arg_ = nullptr;
   };
 }
 
@@ -3740,7 +3634,11 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Mapped_T>)
         {
-          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          klass_.define_method("==", [](T& unordered_map, T& other)->bool
+          {
+            return unordered_map == other;
+          })
+          .define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
             {
               auto it = std::find_if(unordered_map.begin(), unordered_map.end(),
               [&value](auto& pair)
@@ -3750,10 +3648,11 @@ namespace Rice
 
               return it != unordered_map.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -3838,10 +3737,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& unordered_map)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -3932,7 +3831,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -3940,7 +3839,7 @@ namespace Rice
             return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -3966,7 +3865,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }
@@ -3986,7 +3885,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -3994,7 +3893,7 @@ namespace Rice
             return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -4021,7 +3920,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }
@@ -4042,7 +3941,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -4053,7 +3952,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -4080,7 +3979,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }
@@ -4144,7 +4043,7 @@ namespace Rice
       Difference_T normalizeIndex(Size_T size, Difference_T index, bool enforceBounds = false)
       {
         // Negative indices mean count from the right
-        if (index < 0 && (-index <= size))
+        if (index < 0 && ((Size_T)(-index) <= size))
         {
           index = size + index;
         }
@@ -4188,7 +4087,7 @@ namespace Rice
           }
 
           // Wrap the vector
-          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
         });
       }
 
@@ -4204,10 +4103,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("resize", [](const T& vector, Size_T newSize)
-              {
-                // Do nothing
-              });
+          klass_.define_method("resize", [](const T&, Size_T)
+          {
+            // Do nothing
+          });
         }
       }
 
@@ -4264,7 +4163,7 @@ namespace Rice
               return vector[index];
             }
           })
-          .template define_method<Value_T*(T::*)()>("data", &T::data, Return().setBuffer());
+          .template define_method<Value_T*(T::*)()>("data", &T::data, ReturnBuffer());
         }
         else
         {
@@ -4345,7 +4244,11 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<T>)
         {
-          klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
+          klass_.define_method("==", [](T& vector, T& other)->bool
+          {
+            return vector == other;
+          })
+          .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())
@@ -4379,21 +4282,22 @@ namespace Rice
               return iter - vector.begin();
             }
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
-            {
-              return std::nullopt;
-            })
-          .define_method("include?", [](const T& vector, Parameter_T element)
-            {
-              return false;
-            })
-          .define_method("index", [](const T& vector, Parameter_T element) -> std::optional<Difference_T>
-            {
-              return std::nullopt;
-            });
+          klass_.define_method("delete", [](T&, Parameter_T) -> std::optional<Value_T>
+          {
+            return std::nullopt;
+          })
+          .define_method("include?", [](const T&, Parameter_T)
+          {
+            return false;
+          })
+          .define_method("index", [](const T&, Parameter_T) -> std::optional<Difference_T>
+          {
+            return std::nullopt;
+          });
         }
       }
 
@@ -4418,7 +4322,7 @@ namespace Rice
           })
           .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
           {
-            int normalized = normalizeIndex(vector.size(), index, true);
+            size_t normalized = normalizeIndex(vector.size(), index, true);
             // For a Ruby array a positive index means insert the element before the index. But
             // a negative index means insert the element *after* the index. std::vector
             // inserts *before* the index. So add 1 if this is a negative index.
@@ -4517,10 +4421,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& vector)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -4582,7 +4486,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -4592,7 +4496,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -4618,7 +4522,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -4638,7 +4542,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -4648,7 +4552,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -4675,7 +4579,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -4696,7 +4600,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -4709,7 +4613,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -4736,7 +4640,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -4757,7 +4661,7 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
@@ -4767,7 +4671,7 @@ namespace Rice
       }
 
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
   }
 }