perf: optimize type coercion and object conversion

Use set for boolean checks, cache lookups, extract constants.

Author: hakanensari

benchmarks/perf_comparison.rb

@@ -29,15 +29,23 @@
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "structure"
 
-# Test data with coercion
+# Test data with more coercions and nested structures
 TEST_DATA = {
   "attr1" => "foo",
-  "attr2" => "123",
+  "attr2" => "123",         # Integer coercion
   "attr3" => "bar",
-  "attr4" => "true",
+  "attr4" => "true",        # Boolean coercion
   "attr5" => ["a", "b", "c"],
   "attr6" => { "x" => "y" },
   "attr8" => "optional",
+  "attr9" => "3.14",        # Float coercion
+  "attr10" => "42",         # Integer coercion
+  "attr11" => "1",          # Boolean coercion
+  "items" => [ # Array of nested structures
+    { "name" => "Item 1", "price" => "10.99" },
+    { "name" => "Item 2", "price" => "20.50" },
+    { "name" => "Item 3", "price" => "15.25" },
+  ],
 }.freeze
 
 # Define dry-struct models
@@ -48,6 +56,13 @@ module Types
     include Dry.Types()
   end
 
+  class Item < Dry::Struct
+    transform_keys(&:to_sym)
+
+    attribute :name, Types::String
+    attribute :price, Types::Coercible::Float
+  end
+
   class Model < Dry::Struct
     transform_keys(&:to_sym)
 
@@ -59,11 +74,20 @@ class Model < Dry::Struct
     attribute :attr6, Types::Hash
     attribute :attr7, Types::String.default("default")
     attribute? :attr8, Types::String
+    attribute :attr9, Types::Coercible::Float
+    attribute :attr10, Types::Coercible::Integer
+    attribute :attr11, Types::Params::Bool
+    attribute :items, Types::Array.of(Item)
   end
 end
 
 # Define Structure models
 module StructureModels
+  Item = Structure.new do
+    attribute(:name, String)
+    attribute(:price, Float)
+  end
+
   Model = Structure.new do
     attribute(:attr1, String)
     attribute(:attr2, Integer)
@@ -73,6 +97,10 @@ module StructureModels
     attribute(:attr6)
     attribute(:attr7, String, default: "default")
     attribute?(:attr8, String)
+    attribute(:attr9, Float)
+    attribute(:attr10, Integer)
+    attribute(:attr11, :boolean)
+    attribute(:items, ["Item"])
   end
 end
 

lib/structure.rb

@@ -4,6 +4,9 @@
 
 # A library for parsing data into immutable Ruby Data objects with type coercion
 module Structure
+  TO_H_CHECKER = ->(x) { x.respond_to?(:to_h) && x }
+  private_constant :TO_H_CHECKER
+
   class << self
     # Creates a new Data class with attribute definitions and type coercion
     #
@@ -79,7 +82,7 @@ def new(&block)
           v = public_send(m)
           value = case v
           when Array then v.map { |x| x.respond_to?(:to_h) && x ? x.to_h : x }
-          when ->(x) { x.respond_to?(:to_h) && x } then v.to_h
+          when TO_H_CHECKER then v.to_h
           else v
           end
           [m, value]
@@ -103,6 +106,7 @@ def new(&block)
         final       = {}
         mappings    = __structure_meta__[:mappings]
         defaults    = __structure_meta__[:defaults]
+        coercions   = __structure_meta__[:coercions]
         after_parse = __structure_meta__[:after_parse]
         required    = __structure_meta__[:required]
 
@@ -122,7 +126,7 @@ def new(&block)
           end
 
           if value
-            coercion = __structure_meta__[:coercions][attr]
+            coercion = coercions[attr]
             value = coercion.call(value) if coercion
           end
 

lib/structure/types.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Structure
   # Type coercion methods for converting values to specific types
   module Types
     class << self
       # Rails-style boolean truthy values
       # Reference: https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html
-      BOOLEAN_TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"].freeze
+      BOOLEAN_TRUTHY = Set.new([true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"]).freeze
       private_constant :BOOLEAN_TRUTHY
 
       # Main factory method for creating type coercers
@@ -93,12 +95,15 @@ def array(element_type, context = nil)
             value.map { |element| context.parse(element) }
           end
         when String
+          resolved_class = nil
+
           lambda do |value|
             unless value.respond_to?(:map)
               raise TypeError, "can't convert #{value.class} into Array"
             end
 
-            resolved_class = resolve_class(element_type, context)
+            resolved_class ||= resolve_class(element_type, context)
+            # @type var resolved_class: untyped
             value.map { |element| resolved_class.parse(element) }
           end
         else

sig/structure.rbs

@@ -1,4 +1,6 @@
 module Structure
+  TO_H_CHECKER: Proc
+
   interface _StructuredDataClass
     def __structure_meta__: () -> {
       types: Hash[Symbol, untyped],

sig/structure/types.rbs

@@ -4,7 +4,7 @@ module Structure
       def parse: (untyped) -> untyped
     end
 
-    BOOLEAN_TRUTHY: Array[untyped]
+    BOOLEAN_TRUTHY: Set[untyped]
 
     self.@boolean: Proc
     self.@kernel_cache: Hash[untyped, Proc]