sorbet-schema 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4546ee5b80f3b538d7c3f9813501f066ef1f033693f5328f8789f26f9d7537dc
-  data.tar.gz: 3c658049c62dcd8ab506bc3cc72fa926731fd8a712c1436f0277339edc88d290
+  metadata.gz: d6e96bccc5924a52824327d2d5bc3b8e79b887ac31d13b292581c347c1d43480
+  data.tar.gz: 36896e42540d07c714b8075c7c2b89b4d47c5d09d1e098e83ecf050f6c68fa50
 SHA512:
-  metadata.gz: a2f8a6bec49a48abd11c0d6ee1eac7eb9d2a85965a02633635b9361d82bad46bedb6c02d213cf226f6cb644e803c575ded85e3eaf6c06cbe9ae34068e7dd1985
-  data.tar.gz: db1a6c0bf48b2fd6628b77dd324e06b42d9cb7e8e222b54523e0beeb7e10395b5a86d2a3fd7b3afe36453f2b8386f3bde758cbd9893aefee9e8d1fca8490f533
+  metadata.gz: c0a12cf7754d2e13eaebb5a0b042a2abea848dc79aeda84b2887f0c949b523c2aa8a1b3a842562ee053c15dcb3b5a13c6caf1e760bbf9c7f297ea39285c5e1e3
+  data.tar.gz: b72bc80795f41444f06b2aa9bc7186f3669993c95cb7e3e500e021fc2c053c2ac5088d2e3a0efae32aa4e1bd0d35c138602de08fba9f31ded554b43ae7aefd4d

data/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.3](https://github.com/maxveldink/sorbet-schema/compare/v0.9.2...v0.9.3) (2025-12-06)
+
+
+### Performance Improvements
+
+* add deserialization benchmark ([#135](https://github.com/maxveldink/sorbet-schema/issues/135)) ([21d23bb](https://github.com/maxveldink/sorbet-schema/commit/21d23bb51c40ee199cb79a54f06184bb15634909))
+* add serialization benchmarks, refactor to helpers ([#137](https://github.com/maxveldink/sorbet-schema/issues/137)) ([dc43409](https://github.com/maxveldink/sorbet-schema/commit/dc434094511f26ddc37f853295b2f07586826f00))
+* Implement caching for serializers and coercers to improve performance ([#136](https://github.com/maxveldink/sorbet-schema/issues/136)) ([d980292](https://github.com/maxveldink/sorbet-schema/commit/d980292b64630c9ee93f886b10b3b9334b694879))
+* Improve coercer performance by using class methods ([#134](https://github.com/maxveldink/sorbet-schema/issues/134)) ([0336299](https://github.com/maxveldink/sorbet-schema/commit/033629914c7ac0e19d21a725336ff7b9dbc8fc90))
+
 ## [0.9.2](https://github.com/maxveldink/sorbet-schema/compare/v0.9.1...v0.9.2) (2024-09-04)
 
 

data/Gemfile

@@ -6,6 +6,7 @@ source "https://rubygems.org"
 gemspec
 
 group :development do
+  gem "benchmark-ips"
   gem "rake"
   gem "standard"
   gem "standard-performance"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.9.2)
+    sorbet-schema (0.9.3)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
@@ -12,6 +12,7 @@ GEM
   specs:
     ansi (1.5.0)
     ast (2.4.2)
+    benchmark-ips (2.14.0)
     bigdecimal (3.1.8)
     builder (3.3.0)
     debug (1.9.2)
@@ -127,9 +128,11 @@ GEM
 PLATFORMS
   arm64-darwin-22
   arm64-darwin-23
+  arm64-darwin-25
   x86_64-linux
 
 DEPENDENCIES
+  benchmark-ips
   bigdecimal
   debug
   minitest

data/benchmarks/helpers.rb

@@ -0,0 +1,239 @@
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "json"
+require "sorbet-schema"
+
+module BenchmarkHelpers
+  extend T::Sig
+
+  class Rank < T::Enum
+    enums do
+      Ace = new("Ace")
+      King = new("King")
+      Queen = new("Queen")
+      Jack = new("Jack")
+      Ten = new("Ten")
+      Nine = new("Nine")
+      Eight = new("Eight")
+      Seven = new("Seven")
+      Six = new("Six")
+      Five = new("Five")
+      Four = new("Four")
+      Three = new("Three")
+      Two = new("Two")
+    end
+  end
+
+  class Suit < T::Enum
+    enums do
+      Spades = new("Spades")
+      Hearts = new("Hearts")
+      Clubs = new("Clubs")
+      Diamonds = new("Diamonds")
+    end
+  end
+
+  # Define some structs for the benchmark
+  class Card < T::Struct
+    const :rank, Rank
+    const :suit, Suit
+  end
+
+  class Player < T::Struct
+    const :name, String
+    const :hand, T::Array[Card]
+  end
+
+  class Round < T::Struct
+    const :number, Integer
+    const :winner, T.nilable(Player)
+  end
+
+  class Game < T::Struct
+    const :name, String
+    const :players, T::Array[Player]
+    const :rounds, T::Array[Round]
+    const :deck_size, Integer
+    const :shuffled, T::Boolean
+  end
+
+  # Define a struct with MANY fields of the same types that require coercion
+  # This will stress-test coercer caching by reusing the same coercers many times
+  class Humongous < T::Struct
+    const :field_1, Integer
+    const :field_2, Integer
+    const :field_3, Integer
+    const :field_4, Integer
+    const :field_5, Integer
+    const :field_6, Integer
+    const :field_7, Integer
+    const :field_8, Integer
+    const :field_9, Integer
+    const :field_10, Integer
+    const :field_11, Integer
+    const :field_12, Integer
+    const :field_13, Integer
+    const :field_14, Integer
+    const :field_15, Integer
+    const :field_16, Integer
+    const :field_17, Integer
+    const :field_18, Integer
+    const :field_19, Integer
+    const :field_20, Integer
+    const :field_21, Integer
+    const :field_22, Integer
+    const :field_23, Integer
+    const :field_24, Integer
+    const :field_25, Integer
+    const :field_26, Integer
+    const :field_27, Integer
+    const :field_28, Integer
+    const :field_29, Integer
+    const :field_30, Integer
+    const :field_31, Integer
+    const :field_32, Integer
+    const :field_33, Integer
+    const :field_34, Integer
+    const :field_35, Integer
+    const :field_36, Integer
+    const :field_37, Integer
+    const :field_38, Integer
+    const :field_39, Integer
+    const :field_40, Integer
+    const :field_41, Integer
+    const :field_42, Integer
+    const :field_43, Integer
+    const :field_44, Integer
+    const :field_45, Integer
+    const :field_46, Integer
+    const :field_47, Integer
+    const :field_48, Integer
+    const :field_49, Integer
+    const :field_50, Integer
+
+    const :float_1, Float
+    const :float_2, Float
+    const :float_3, Float
+    const :float_4, Float
+    const :float_5, Float
+    const :float_6, Float
+    const :float_7, Float
+    const :float_8, Float
+    const :float_9, Float
+    const :float_10, Float
+    const :float_11, Float
+    const :float_12, Float
+    const :float_13, Float
+    const :float_14, Float
+    const :float_15, Float
+    const :float_16, Float
+    const :float_17, Float
+    const :float_18, Float
+    const :float_19, Float
+    const :float_20, Float
+
+    const :bool_1, T::Boolean
+    const :bool_2, T::Boolean
+    const :bool_3, T::Boolean
+    const :bool_4, T::Boolean
+    const :bool_5, T::Boolean
+    const :bool_6, T::Boolean
+    const :bool_7, T::Boolean
+    const :bool_8, T::Boolean
+    const :bool_9, T::Boolean
+    const :bool_10, T::Boolean
+    const :bool_11, T::Boolean
+    const :bool_12, T::Boolean
+    const :bool_13, T::Boolean
+    const :bool_14, T::Boolean
+    const :bool_15, T::Boolean
+    const :bool_16, T::Boolean
+    const :bool_17, T::Boolean
+    const :bool_18, T::Boolean
+    const :bool_19, T::Boolean
+    const :bool_20, T::Boolean
+
+    const :sym_1, Symbol
+    const :sym_2, Symbol
+    const :sym_3, Symbol
+    const :sym_4, Symbol
+    const :sym_5, Symbol
+    const :sym_6, Symbol
+    const :sym_7, Symbol
+    const :sym_8, Symbol
+    const :sym_9, Symbol
+    const :sym_10, Symbol
+    const :sym_11, Symbol
+    const :sym_12, Symbol
+    const :sym_13, Symbol
+    const :sym_14, Symbol
+    const :sym_15, Symbol
+    const :sym_16, Symbol
+    const :sym_17, Symbol
+    const :sym_18, Symbol
+    const :sym_19, Symbol
+    const :sym_20, Symbol
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def self.game_data
+    {
+      name: "Poker",
+      players: Array.new(10) do |i|
+        {
+          name: "Player #{i}",
+          hand: [
+            {rank: "Ace", suit: "Spades"},
+            {rank: "King", suit: "Spades"}
+          ]
+        }
+      end,
+      rounds: Array.new(5) do |i|
+        {
+          number: i + 1,
+          winner: {
+            name: "Player #{i % 2}",
+            hand: [
+              {rank: "Queen", suit: "Hearts"},
+              {rank: "Jack", suit: "Hearts"}
+            ]
+          }
+        }
+      end,
+      deck_size: 52,
+      shuffled: true
+    }
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def self.humongous_data
+    {
+      field_1: "1", field_2: "2", field_3: "3", field_4: "4", field_5: "5",
+      field_6: "6", field_7: "7", field_8: "8", field_9: "9", field_10: "10",
+      field_11: "11", field_12: "12", field_13: "13", field_14: "14", field_15: "15",
+      field_16: "16", field_17: "17", field_18: "18", field_19: "19", field_20: "20",
+      field_21: "21", field_22: "22", field_23: "23", field_24: "24", field_25: "25",
+      field_26: "26", field_27: "27", field_28: "28", field_29: "29", field_30: "30",
+      field_31: "31", field_32: "32", field_33: "33", field_34: "34", field_35: "35",
+      field_36: "36", field_37: "37", field_38: "38", field_39: "39", field_40: "40",
+      field_41: "41", field_42: "42", field_43: "43", field_44: "44", field_45: "45",
+      field_46: "46", field_47: "47", field_48: "48", field_49: "49", field_50: "50",
+      float_1: "1.1", float_2: "2.2", float_3: "3.3", float_4: "4.4", float_5: "5.5",
+      float_6: "6.6", float_7: "7.7", float_8: "8.8", float_9: "9.9", float_10: "10.1",
+      float_11: "11.1", float_12: "12.2", float_13: "13.3", float_14: "14.4", float_15: "15.5",
+      float_16: "16.6", float_17: "17.7", float_18: "18.8", float_19: "19.9", float_20: "20.1",
+      bool_1: "true", bool_2: "false", bool_3: "true", bool_4: "false", bool_5: "true",
+      bool_6: "false", bool_7: "true", bool_8: "false", bool_9: "true", bool_10: "false",
+      bool_11: "true", bool_12: "false", bool_13: "true", bool_14: "false", bool_15: "true",
+      bool_16: "false", bool_17: "true", bool_18: "false", bool_19: "true", bool_20: "false",
+      sym_1: "sym1", sym_2: "sym2", sym_3: "sym3", sym_4: "sym4", sym_5: "sym5",
+      sym_6: "sym6", sym_7: "sym7", sym_8: "sym8", sym_9: "sym9", sym_10: "sym10",
+      sym_11: "sym11", sym_12: "sym12", sym_13: "sym13", sym_14: "sym14", sym_15: "sym15",
+      sym_16: "sym16", sym_17: "sym17", sym_18: "sym18", sym_19: "sym19", sym_20: "sym20"
+    }
+  end
+end
+

data/benchmarks/many_fields_deserialization.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "benchmark/ips"
+require_relative "helpers"
+
+humongous_schema = Typed::Schema.from_struct(BenchmarkHelpers::Humongous)
+humongous_data = BenchmarkHelpers.humongous_data
+humongous_json = JSON.generate(humongous_data)
+
+Benchmark.ips do |x|
+  x.report("hash deserialization with many fields") do
+    humongous_schema.from_hash(humongous_data)
+  end
+
+  x.report("json deserialization with many fields") do
+    humongous_schema.from_json(humongous_json)
+  end
+
+  x.compare!
+end

data/benchmarks/many_fields_serialization.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "benchmark/ips"
+require_relative "helpers"
+
+humongous_schema = Typed::Schema.from_struct(BenchmarkHelpers::Humongous)
+humongous_data = BenchmarkHelpers.humongous_data
+humongous_struct = humongous_schema.from_hash(humongous_data).payload
+
+hash_serializer = Typed::HashSerializer.new(schema: humongous_schema)
+json_serializer = Typed::JSONSerializer.new(schema: humongous_schema)
+
+Benchmark.ips do |x|
+  x.report("hash serialization with many fields") do
+    hash_serializer.serialize(humongous_struct)
+  end
+
+  x.report("json serialization with many fields") do
+    json_serializer.serialize(humongous_struct)
+  end
+
+  x.compare!
+end
+

data/benchmarks/simple_deserialization.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "benchmark/ips"
+require_relative "helpers"
+
+game_schema = Typed::Schema.from_struct(BenchmarkHelpers::Game)
+game_data = BenchmarkHelpers.game_data
+game_json = JSON.generate(game_data)
+
+Benchmark.ips do |x|
+  x.report("simple hash deserialization") do
+    game_schema.from_hash(game_data)
+  end
+
+  x.report("simple json deserialization") do
+    game_schema.from_json(game_json)
+  end
+
+  x.compare!
+end

data/benchmarks/simple_serialization.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "benchmark/ips"
+require_relative "helpers"
+
+game_schema = Typed::Schema.from_struct(BenchmarkHelpers::Game)
+game_data = BenchmarkHelpers.game_data
+game_struct = game_schema.from_hash(game_data).payload
+
+hash_serializer = Typed::HashSerializer.new(schema: game_schema)
+json_serializer = Typed::JSONSerializer.new(schema: game_schema)
+
+Benchmark.ips do |x|
+  x.report("simple hash serialization") do
+    hash_serializer.serialize(game_struct)
+  end
+
+  x.report("simple json serialization") do
+    json_serializer.serialize(game_struct)
+  end
+
+  x.compare!
+end
+

data/lib/sorbet-schema/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module SorbetSchema
-  VERSION = "0.9.2"
+  VERSION = "0.9.3"
 end

data/lib/typed/coercion/boolean_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: T::Boolean} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type == T::Utils.coerce(T::Boolean)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a T::Boolean.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a T::Boolean.")) unless self.class.used_for_type?(type)
 
         if type.recursively_valid?(value)
           Success.new(value)

data/lib/typed/coercion/coercer.rb

@@ -11,7 +11,7 @@ module Typed
       Target = type_member(:out)
 
       sig { abstract.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
       end
 
       sig { abstract.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }

data/lib/typed/coercion/coercer_registry.rb

@@ -45,7 +45,7 @@ module Typed
 
       sig { params(type: T::Types::Base).returns(T.nilable(T.class_of(Coercer))) }
       def select_coercer_by(type:)
-        @available.find { |coercer| coercer.new.used_for_type?(type) }
+        @available.find { |coercer| coercer.used_for_type?(type) }
       end
     end
   end

data/lib/typed/coercion/date_coercer.rb

@@ -10,13 +10,13 @@ module Typed
       Target = type_member { {fixed: Date} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         T::Utils.coerce(type) == T::Utils.coerce(Date)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a Date.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a Date.")) unless self.class.used_for_type?(type)
 
         return Success.new(value) if value.is_a?(Date)
 

data/lib/typed/coercion/date_time_coercer.rb

@@ -10,13 +10,13 @@ module Typed
       Target = type_member { {fixed: DateTime} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         T::Utils.coerce(type) == T::Utils.coerce(DateTime)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a DateTime.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a DateTime.")) unless self.class.used_for_type?(type)
 
         return Success.new(value) if value.is_a?(DateTime)
 

data/lib/typed/coercion/enum_coercer.rb

@@ -8,7 +8,7 @@ module Typed
       Target = type_member { {fixed: T::Enum} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         return false unless type.respond_to?(:raw_type)
 
         !!(T.cast(type, T::Types::Simple).raw_type < T::Enum)
@@ -16,7 +16,7 @@ module Typed
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must inherit from T::Enum for Enum coercion.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Enum for Enum coercion.")) unless self.class.used_for_type?(type)
 
         Success.new(T.cast(type, T::Types::Simple).raw_type.from_serialized(value))
       rescue KeyError => e

data/lib/typed/coercion/float_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: Float} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         T::Utils.coerce(type) == T::Utils.coerce(Float)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a Float.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a Float.")) unless self.class.used_for_type?(type)
 
         Success.new(Float(value))
       rescue ArgumentError, TypeError

data/lib/typed/coercion/integer_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: Integer} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type == T::Utils.coerce(Integer)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a Integer.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a Integer.")) unless self.class.used_for_type?(type)
 
         Success.new(Integer(value))
       rescue ArgumentError, TypeError

data/lib/typed/coercion/string_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: String} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type == T::Utils.coerce(String)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a String.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a String.")) unless self.class.used_for_type?(type)
 
         Success.new(String(value))
       end

data/lib/typed/coercion/struct_coercer.rb

@@ -8,7 +8,7 @@ module Typed
       Target = type_member { {fixed: T::Struct} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         return false unless type.respond_to?(:raw_type)
 
         !!(T.cast(type, T::Types::Simple).raw_type < T::Struct)
@@ -16,7 +16,7 @@ module Typed
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless self.class.used_for_type?(type)
         return Success.new(value) if type.recursively_valid?(value)
 
         return Failure.new(CoercionError.new("Value of type '#{value.class}' cannot be coerced to #{type} Struct.")) unless value.is_a?(Hash)

data/lib/typed/coercion/symbol_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: Symbol} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type == T::Utils.coerce(Symbol)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Type must be a Symbol.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Type must be a Symbol.")) unless self.class.used_for_type?(type)
 
         if value.respond_to?(:to_sym)
           Success.new(value.to_sym)

data/lib/typed/coercion/typed_array_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: T::Array[T.untyped]} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type.is_a?(T::Types::TypedArray)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must be a T::Array.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Field type must be a T::Array.")) unless self.class.used_for_type?(type)
         return Failure.new(CoercionError.new("Value must be an Array.")) unless value.is_a?(Array)
 
         return Success.new(value) if type.recursively_valid?(value)

data/lib/typed/coercion/typed_hash_coercer.rb

@@ -8,13 +8,13 @@ module Typed
       Target = type_member { {fixed: T::Hash[T.untyped, T.untyped]} }
 
       sig { override.params(type: T::Types::Base).returns(T::Boolean) }
-      def used_for_type?(type)
+      def self.used_for_type?(type)
         type.is_a?(T::Types::TypedHash)
       end
 
       sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
       def coerce(type:, value:)
-        return Failure.new(CoercionError.new("Field type must be a T::Hash.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Field type must be a T::Hash.")) unless self.class.used_for_type?(type)
         return Failure.new(CoercionError.new("Value must be a Hash.")) unless value.is_a?(Hash)
 
         return Success.new(value) if type.recursively_valid?(value)

data/lib/typed/schema.rb

@@ -20,12 +20,12 @@ module Typed
 
     sig { params(hash: Typed::HashSerializer::InputHash).returns(Typed::Serializer::DeserializeResult) }
     def from_hash(hash)
-      Typed::HashSerializer.new(schema: self).deserialize(hash)
+      hash_serializer.deserialize(hash)
     end
 
     sig { params(json: String).returns(Typed::Serializer::DeserializeResult) }
     def from_json(json)
-      Typed::JSONSerializer.new(schema: self).deserialize(json)
+      json_serializer.deserialize(json)
     end
 
     sig { params(field_name: Symbol, serializer: Field::InlineSerializer).returns(Schema) }
@@ -41,5 +41,19 @@ module Typed
         end
       )
     end
+
+    private
+
+    sig { returns(Typed::HashSerializer) }
+    def hash_serializer
+      @hash_serializer = T.let(@hash_serializer, T.nilable(Typed::HashSerializer))
+      @hash_serializer ||= Typed::HashSerializer.new(schema: self)
+    end
+
+    sig { returns(Typed::JSONSerializer) }
+    def json_serializer
+      @json_serializer = T.let(@json_serializer, T.nilable(Typed::JSONSerializer))
+      @json_serializer ||= Typed::JSONSerializer.new(schema: self)
+    end
   end
 end