dry-types-tuple 0.1.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ff4a6208f9f1d2b30e3956b6493cc13e20f095d86c5be454f201fbdea0316dc
-  data.tar.gz: d4ec021dc5a952a6d238af76a05df9d573643169d1ada1e6ad4823fb63cfcd0b
+  metadata.gz: d045e436a8d045af55c65dd3278b67ef1c07fd90971ceea8a3fa2bf7e39279d9
+  data.tar.gz: 769f6744fe426662e65f4f6c8314f4d62f41f1f73b700ab4a39d992f6faf298a
 SHA512:
-  metadata.gz: e50016534bb0db3324c8cdd2640a11595fb990c58b43228368e22dc87ca981557cc0c2d286c68aacbb73b2bc55e0869531e3ec88eab91551930c89aaf719cff4
-  data.tar.gz: 62c1d224167979f49826e960100699e944afecd0cc1a31479c0aef31f12efe9834e9bb8d6baaa0d6fde11745ed1b426743dc4442153439e883c816a7d80ca188
+  metadata.gz: 7ca8466bb3dfbae6b6d7265bd1f84d7c930747748476c0b1c3c7d1ee6894e08e5f753ac35dc5f6902657ad438d135b39fd31b78433983e73cb57abafb6fdf58a
+  data.tar.gz: 1a558eebab32a111fbcb8899b524cfc74a9fba7b901c98dcb4c4084cdff76847b6692fe7e21b0f31a62b01834e934ea4c1150c52a749552e05a90f923e2c7e1b

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.1 2025-06-26
+
+- Change minimal ruby version to 3.1
+- Use zeitwerk
+- Inherit `Dry::Tuple::Struct` from `Dry::Struct`, optionally provide `Dry::Tuple::Struct::ClassInterface` mixin.
+- Implement Dry::Types[] inferrer syntax
+- Some refactorings, docs & examples
+
 ## 0.0.1 2023-01-26
 
 First public release

data/README.md

@@ -84,7 +84,7 @@ class Example
   extend Dry::Tuple::ClassInterface
   tuple Types.Tuple(Types.Value(:example) << Types::Coercible::Symbol, Types::String)
 
-  def initializer(left, right)
+  def initialize(left, right)
     @left, @right = left, right
   end
 
@@ -105,7 +105,7 @@ end
 class OtherExample < Example
   tuple Types.Tuple(Types.Value(:other_example) << Types::Coercible::Symbol, [Types::Any])
 
-  def initializer(left, right, *rest)
+  def initialize(left, right, *rest)
     super(left, right)
     @rest = rest
   end
@@ -115,8 +115,8 @@ ExampleSum = Example | OtherExample
 ExampleSum[['example', 'foo']]
 # => #<Example @left = :example, @right = 'foo'>
 
-ExampleSum[['other_example', 1, '2', {}]].class
-# => #<Example @left = :other_example, @right = 1, @rest = ['2', {}]>
+ExampleSum[['other_example', 1, '2', {}]]
+# => #<OtherExample @left = :other_example, @right = 1, @rest = ['2', {}]>
 ```
 
 #### Class interface for Dry::Struct classes.

data/dry-types-tuple.gemspec

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require_relative "lib/dry/tuple/version.rb"
+
 Gem::Specification.new do |spec|
   spec.name = "dry-types-tuple"
-  spec.version = '0.1.2'
-  spec.authors = ["Anton"]
+  spec.version = Dry::Tuple::VERSION
+  spec.authors = ["Anton Semenov"]
   spec.email = ["anton.estum@gmail.com"]
 
   spec.summary = "Dry::Types::Tuple"
   spec.description = "The Tuple type implementation for Dry::Types."
   spec.homepage = "https://github.com/estum/dry-types-tuple"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["homepage_uri"]      = spec.homepage
@@ -28,7 +30,9 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "zeitwerk"
   spec.add_dependency "dry-types"
+  spec.add_dependency "dry-core"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/dry/tuple/class_decorator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Dry
+  module Tuple
+    # Pure class type decorator mixin.
+    module ClassDecorator
+      # @param input [Array]
+      #   the result of {#coerce_tuple}
+      # @return [self]
+      # @abstract
+      #   Redefine to handle input transformations. For example to splat input array.
+      # @note
+      #   Will be invoked on input that was passed thru tuple validation & coercion.
+      def new_from_tuple(input)
+        defined?(super) ? super(input) : new(input)
+      end
+
+      # @param input [Array<Mixed>]
+      #   the result of {Types::Tuple#call}
+      # @return [Array]
+      #   coerced input
+      # @note
+      #   Will be invoked on input that was passed thru tuple validation & coercion.
+      def coerce_tuple(input)
+        defined?(super) ? super(input) : input
+      end
+
+      # @api private
+      def call_safe(input, &block)
+        if input.is_a?(self)
+          input
+        elsif input.is_a?(Array)
+          resolve_tuple_safe(input, &block)
+        else
+          super(input, &block)
+        end
+      end
+
+      # @api private
+      def call_unsafe(input)
+        if input.is_a?(self)
+          input
+        elsif input.is_a?(Array)
+          resolve_tuple_unsafe(input)
+        else
+          super
+        end
+      end
+
+      private
+
+      # @api private
+      def resolve_tuple_safe(input)
+        input = tuple.call_safe(input) do |output = input|
+          output = yield(output) if block_given?
+          return output
+        end
+        new_from_tuple(coerce_tuple(input))
+      end
+
+      # @api private
+      def resolve_tuple_unsafe(input)
+        input = tuple.call_unsafe(input)
+        new_from_tuple(coerce_tuple(input))
+      end
+    end
+  end
+end

data/lib/dry/tuple/class_interface.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/core/class_attributes"
+require "dry/types/type"
+require "dry/types/builder"
+require "dry/types/decorator"
+
+module Dry
+  module Tuple
+    # Universal class interface
+    # @example Usage
+    #   class SomeClass
+    #     extend Dry::Tuple::ClassInterface
+    #     tuple [Dry::Types['coercible.integer'], Dry::Types['string']]
+    #
+    #     def initialize(a, b)
+    #       @a, @b = a, b
+    #     end
+    #   end
+    module ClassInterface
+      include Dry::Core::ClassAttributes
+      include Dry::Types::Type
+      include Dry::Types::Builder
+      include Dry::Types::Decorator
+      include ClassDecorator
+
+      # @return [Dry::Types::Tuple]
+      def type = @tuple
+
+      # @!method tuple()
+      #   @overload tuple(input)
+      #     @param input [Mixed]
+      #     @see TypeCoercer#call
+      #   @overload tuple()
+      #     @return [Dry::Types::Tuple]
+
+      # @api private
+      def self.extended(base)
+        base.defines :tuple, coerce: TypeCoercer
+        super
+      end
+    end
+  end
+end

data/lib/dry/tuple/struct.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+
+module Dry
+  module Tuple
+    # {Dry::Struct} abstract subclass extended with {Dry::Types::Struct::ClassInterface}
+    #
+    # @example Usage
+    #   class Ambivalent < Dry::Tuple::Struct
+    #     attribute :left, Dry::Types['coercible.string']
+    #     attribute :right, Dry::Types['coercible.string']
+    #
+    #     # set key order
+    #     auto_tuple :left, :right
+    #   end
+    #
+    #   class AmbivalentButPrefer < Ambivalent
+    #     attribute :prefer, Dry::Types['coercible.symbol'].enum(:left, :right)
+    #     auto_tuple :prefer
+    #   end
+    class Struct < Dry::Struct
+      abstract
+
+      # Extracted due to make it possible to use this feature within {Dry::Struct} classes.
+      # @example extending Dry::Struct subclass
+      #
+      #   class SomeStruct < Dry::Struct
+      #     attribute :some, Types::Integer
+      #     attribute :with, Types::Hash
+      #
+      #     extend ::Dry::Tuple::Struct::ClassInterface
+      #     auto_tuple :some, :with
+      #   end
+      module ClassInterface
+        include ClassDecorator
+
+        # Merges the given keys into the #{keys_order} and redefines the +tuple+ of class.
+        # @param keys [Array<Symbol>]
+        # @return [void]
+        def auto_tuple(*keys)
+          keys_order(keys_order | keys)
+          index = schema.keys.map { |t| [t.name, t.type] }.to_h
+          tuple Dry::Types::Tuple.coerce(index.values_at(*keys_order))
+        end
+
+        # Constructs a hash of struct attributes from the given array by zipping within {#keys_order}.
+        # @param input [Array<Any>]
+        # @return [Hash]
+        def coerce_tuple(input)
+          keys_order.zip(input).to_h
+        end
+
+        # @return [Dry::Types::Result]
+        def try(input, &block)
+          if input.is_a?(::Array)
+            tuple.try(input, &block)
+          else
+            super(input, &block)
+          end
+        end
+
+        # @api private
+        def self.extended(base)
+          base.defines :tuple, coerce: TypeCoercer
+          base.defines :keys_order, type: Dry::Types['array<symbol>']
+          base.keys_order EMPTY_ARRAY
+          super
+        end
+      end
+
+      extend ClassInterface
+    end
+  end
+end

data/lib/dry/tuple/type_coercer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dry
+  module Tuple
+    module TypeCoercer
+      module_function
+
+      # @overload Coercer.call(array)
+      #   @param array [Array<Mixed>]
+      # @overload Coercer.call(input)
+      #   @param tuple [Dry::Types::Tuple]
+      # @overload Coercer.call(type)
+      #   @param type [Dry::Types::Constrained]
+      # @example Usage
+      #   Dry::Types::Tuple::Coercer.([Dry::Types['any'], Dry::Types['string']])
+      def call(input, returns: Undefined)
+        case input when Array
+          Dry::Types::Tuple.coerce(input)
+        when Dry::Types::Tuple
+          Undefined.default(returns, input)
+        when Dry::Types::Constrained
+          call(input.type, returns: input)
+        when NilClass
+          Dry::Types['nominal.tuple']
+        end
+      end
+
+      # @see Tuple.coerce
+      # @example Usage
+      #   Dry::Types::Tuple::Coercer[Dry::Types['any'], Dry::Types['string']]
+      def [](*input, **opts)
+        call(input, **opts)
+      end
+    end
+  end
+end

data/lib/dry/tuple/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Tuple
+    VERSION = '0.3.1'
+  end
+end

data/lib/dry/tuple.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/types/tuple'
+require "dry/tuple/version"
+require "zeitwerk"
+require "dry/core"
 
 module Dry
   # The namespace contains mixins for class decoration with tuple type.
@@ -22,121 +24,34 @@ module Dry
   #     end
   #   end
   module Tuple
-    # Pure class type decorator mixin.
-    module ClassDecorator
-      include Types::Decorator
-
-      # @return [@tuple]
-      def type
-        @tuple
-      end
-
-      # @param input [Array] the result of {#coerce_tuple}
-      # @return [self]
-      # @abstract
-      #   It is designed to be redefined for example to splat arguments on constructor.
-      # @note
-      #   Will be invoked on input that was passed thru tuple validation & coercion.
-      def new_from_tuple(input)
-        defined?(super) ? super(input) : new(input)
-      end
-
-      # @param input [Array] the result of tuple#call
-      # @return [Array] coerced input
-      # @note
-      #   Will be invoked on input that was passed thru tuple validation & coercion.
-      def coerce_tuple(input)
-        defined?(super) ? super(input) : input
-      end
-
-      # @api private
-      def call_safe(input, &block)
-        if input.is_a?(self)
-          input
-        elsif input.is_a?(Array)
-          resolve_tuple_safe(input, &block)
-        else
-          super
-        end
-      end
-
-      # @api private
-      def call_unsafe(input)
-        if input.is_a?(self)
-          input
-        elsif input.is_a?(Array)
-          resolve_tuple_unsafe(input)
-        else
-          super
-        end
-      end
-
-      private
-
-      # @api private
-      def resolve_tuple_safe(input)
-        input = tuple.call_safe(input) do |output = input|
-          output = yield(output) if block_given?
-          return output
+    include Dry::Core::Constants
+
+    # rubocop:disable Metrics/MethodLength
+
+    # @api private
+    def self.loader
+      @loader ||=
+        ::Zeitwerk::Loader.new.tap do |loader|
+          root = ::File.expand_path("..", __dir__)
+          warn root
+          loader.tag = "dry-types-tuple"
+          loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-types-tuple.rb")
+          loader.push_dir root
+          loader.ignore \
+            "#{root}/dry-types-tuple.rb",
+            "#{root}/dry/types",
+            # "#{root}/dry/tuple.rb",
+            "#{root}/dry/tuple/{struct,version}.rb"
+
+          if defined?(Pry)
+            loader.log!
+            loader.enable_reloading
+          end
         end
-        new_from_tuple(coerce_tuple(input))
-      end
-
-      # @api private
-      def resolve_tuple_unsafe(input)
-        input = tuple.call_unsafe(input)
-        new_from_tuple(coerce_tuple(input))
-      end
-    end
-
-    module HookExtendObject
-      # Makes the module's features to be prepended instead of appended to the target class when extended.
-      # Also defines the `tuple` class attribute.
-      # @api private
-      private def extend_object(base)
-        base.singleton_class.prepend(self)
-        base.defines :tuple
-      end
-    end
-
-    module ClassInterface
-      include Core::ClassAttributes
-      include Types::Type
-      include Types::Builder
-      include ClassDecorator
-      extend HookExtendObject
     end
 
-    # Extracted due to make it possible to use this feature within {Dry::Struct} classes.
-    # @example extending Dry::Struct subclass
-    #
-    #   class SomeStruct < Dry::Struct
-    #     attribute :some, Types::Integer
-    #     attribute :with, Types::Hash
-    #     extend ::Dry::Tuple::StructClassInterface
-    #     auto_tuple :some, :with
-    #   end
-    module StructClassInterface
-      include ClassDecorator
-      extend HookExtendObject
+    # rubocop:enable Metrics/MethodLength
 
-      class << self
-        private def extend_object(base)
-          super
-          base.defines :keys_order
-          base.keys_order []
-        end
-      end
-
-      def auto_tuple(*keys)
-        keys_order(keys_order | keys)
-        index = schema.keys.map { |t| [t.name, t.type] }.to_h
-        tuple Dry::Types::Tuple.build_unsplat(index.values_at(*keys_order))
-      end
-
-      def coerce_tuple(input)
-        keys_order.zip(input).to_h
-      end
-    end
+    loader.setup
   end
-end
+end

data/lib/dry/types/tuple.rb

@@ -9,53 +9,70 @@ module Dry
     #   )
     #   Types::ServiceArgs[['thumb', '300', '300', 'sample']]
     #   # => [:thumb, 300, 300, "sample"]
-    class Tuple < Array
+    class Tuple < Nominal
+      # VERSION ||= Dry::Tuple::VERSION
+
       # Build a tuple type.
       #
-      # @overload Tuple.build(*fixed_types, rest_type)
+      # @overload self.build(*fixed_types, rest_type)
       #   @param [Array<Dry::Types::Type>] fixed_types
       #   @param [Array(Dry::Types::Type)] rest_type
-      # @see build_index
+      # @see self.build_index
       # @return [Dry::Types::Tuple]
-      def self.build(*types)
-        build_unsplat(types)
-      end
-
-      # @api private
-      def self.build_unsplat(types)
-        new(::Array, types_index: build_index(types))
+      def self.build(*types, **opts)
+        coerce(types, **opts)
       end
 
       # Prepares types index for the Tuple
-      # @param [Array<Dry::Types::Type>] types
-      # @see extract_rest
-      # @return [Dry::Core::Constants::Undefined, Dry::Types::Type]
+      # @see self.extract_rest
+      # @param types [Array<Type>]
+      # @return [Hash { Integer => Type }]
       def self.build_index(types)
-        rest_type = extract_rest(types)
-        types_index = ::Hash[types.size.times.zip(types)]
-        types_index.default = Undefined.default(rest_type, nil)
+        types_index = {}
+
+        Undefined.map(extract_rest(types)) do |rest_type|
+          types_index.default = rest_type
+        end
+
+        types.each_with_index do |type, index|
+          types_index[index] = type
+        end
+
         types_index
       end
 
-      # Extracts and unwraps the rest type
-      # @param [Array<Dry::Types::Type>] types
-      # @return [Dry::Core::Constants::Undefined, Dry::Types::Type]
+      # Extracts the rest type or types.
+      # More than one types in list will be composed to {Sum}.
+      # @note
+      #   Destructive on input arrays.
+      # @param types [Array<Type, Sum>]
+      # @return [Undefined, Type, Sum]
       def self.extract_rest(types)
-        if !types[-1].is_a?(::Array)
-          return Undefined
-        end
-
-        if types[-1].size > 1
-          raise ArgumentError, "rest_type should be an Array with single element to apply to the rest of items: #{types[-1]}"
+        case types
+        in *head, ::Array => rest if rest.size > 0
+          types.replace(head)
+          rest.reduce(:|)
+        else
+          Undefined
         end
+      end
 
-        types.pop[0]
+      # @api private
+      def self.coerce(types, **opts)
+        types_index = build_index(types)
+        new(::Array, **opts, types_index:)
       end
 
-      def initialize(_primitive, types_index: EMPTY_HASH, meta: EMPTY_HASH)
-        super(_primitive, types_index: types_index, meta: meta)
+      singleton_class.alias_method :build_unsplat, :coerce
+
+      # @param primitive [Class]
+      # @return [self]
+      def initialize(primitive, types_index: EMPTY_HASH, meta: EMPTY_HASH, **opts)
+        super(primitive, **opts, types_index:, meta:)
       end
 
+      # @api public
+
       # @see Tuple.build
       # @return [Dry::Types::Tuple]
       def of(*types)
@@ -63,92 +80,59 @@ module Dry
       end
 
       # @return [Hash]
-      #
-      # @api public
-      def types_index
-        options[:types_index]
-      end
+      def types_index = options[:types_index]
 
       # @return [Array<Type>]
-      #
-      # @api public
-      def fixed_types
-        options[:types_index].values
-      end
+      def fixed_types = types_index.values
 
       # @return [Type]
-      #
-      # @api public
-      def rest_type
-        options[:types_index].default
-      end
+      def rest_type = types_index.default
 
       # @return [String]
-      #
-      # @api public
-      def name
-        "Tuple"
-      end
-
-      # @param [Array] tuple
-      #
-      # @return [Array]
-      #
-      # @api private
-      def call_unsafe(tuple)
-        try(tuple) { |failure|
-          raise MapError, failure.error.message
-        }.input
-      end
-
-      # @param [Array] tuple
-      #
-      # @return [Array]
-      #
-      # @api private
-      def call_safe(tuple)
-        try(tuple) { return yield }.input
-      end
+      def name = 'Tuple'
 
       # @param [Array] tuple
-      #
       # @return [Result]
-      #
-      # @api public
       def try(tuple)
         result = coerce(tuple)
         return result if result.success? || !block_given?
-
         yield(result)
       end
 
       # Build a lax type
-      #
       # @return [Lax]
-      #
-      # @api public
       def lax
-        lax_types_index = types_index.transform_values(&:lax)
-        Lax.new(Tuple.new(primitive, **options, types_index: lax_types_index, meta: meta))
+        types_index = types_index().transform_values(&:lax)
+        types_index.default = rest_type.lax if rest_type
+        Lax.new(Tuple.new(primitive, **options, types_index:, meta:))
       end
 
       # @param meta [Boolean] Whether to dump the meta to the AST
-      #
       # @return [Array] An AST representation
-      #
-      # @api public
       def to_ast(meta: true)
-        structure = [*fixed_types.map { |type| type.to_ast(meta: meta) }]
-        structure << [rest_type.to_ast(meta: meta)] unless rest_type.nil?
-        structure << meta ? self.meta : EMPTY_HASH
+        structure = [*fixed_types.map { _1.to_ast(meta:) }]
+        structure << [rest_type.to_ast(meta:)] unless rest_type.nil?
+        structure << meta ? meta() : EMPTY_HASH
         [:tuple, structure]
       end
 
       # @return [Boolean]
-      #
-      # @api public
       def constrained?
-        rest_type&.constrained? || options[:types_index].each_value.any?(&:constrained?)
+        rest_type&.constrained? || types_index.each_value.any?(&:constrained?)
+      end
+
+      # @param tuple [Array]
+      # @return [Array]
+      # @api private
+      def call_unsafe(tuple)
+        try(tuple) { raise MapError, _1.error.message }.input
+      end
+
+      # @param tuple [Array]
+      # @return [Array]
+      # @api private
+      def call_safe(tuple)
+        try(tuple) { return yield }.input
       end
 
       private
@@ -156,25 +140,23 @@ module Dry
       # @api private
       def coerce(input)
         unless primitive?(input)
-          return failure(
-            input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
-          )
+          return failure(input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}"))
         end
 
         output = []
         failures = []
 
         input.each_with_index do |value, index|
-          res_i = types_index[index]&.try(value)
+          item = types_index[index]&.try(value)
 
-          if res_i.nil?
+          if item.nil?
             failures << CoercionError.new("#{value.inspect} not fits to the fixed-size tuple")
             break
-          elsif res_i.failure?
-            failures << res_i.error
+          elsif item.failure?
+            failures << item.error
             break
           else
-            output << res_i.input
+            output << item.input
           end
         end
 
@@ -189,13 +171,13 @@ module Dry
     module BuilderMethods
       # Build a tuple type.
       #
-      # @see Dry::Types::Tuple#build
+      # @see Tuple.build
       # @overload Tuple(*fixed_types, rest_type)
-      #   @param [Array<Dry::Types::Type>] fixed_types
-      #   @param [Array(Dry::Types::Type)] rest_type
-      # @return [Dry::Types::Tuple]
-      def Tuple(*types)
-        Tuple.build(*types)
+      #   @param [Array<Type>] fixed_types
+      #   @param [Array(Type)] rest_type
+      # @return [Tuple]
+      def Tuple(...)
+        Tuple.build(...)
       end
     end
 
@@ -211,26 +193,63 @@ module Dry
 
         visit_options(options, tuple.meta) do |opts|
           header = "Tuple<"
-          rest = visit(types.default) { |type| "*: #{type}" } if types.default
+          rest = visit(types.default) { "*: #{_1}" } if types.default
 
           if size.zero?
             yield "#{header}>#{opts}"
           else
-            yield header.dup << (types.map { |pos, pos_type|
-              visit(pos_type) { |type| "#{pos}: #{type}" }
-              } << rest).compact.join(", ") << ">#{opts}"
+            yield header.dup << (
+              types.flat_map do |pos, pos_types|
+                Kernel.Array(pos_types).map do |pos_type|
+                  visit(pos_type) { "#{pos}: #{_1}" }
+                end
+              end << rest
+            ).compact.join(", ") << ">#{opts}"
           end
         end
       end
     end
 
-    register "nominal.tuple", Types::Tuple.build([self['any']])
+    nominal_tuple = Tuple.build([self['any']])
+
+    register "nominal.tuple", nominal_tuple
 
-    type = self["nominal.tuple"].constrained(type: ::Array)
+    strict_tuple = nominal_tuple.constrained(type: ::Array)
+
+    register "tuple", strict_tuple
+    register "strict.tuple", strict_tuple
+    register "coercible.tuple", nominal_tuple.constructor(Kernel.method(:Array))
+    register "params.tuple", nominal_tuple.constructor(Coercions::Params.method(:to_ary))
+
+    TUPLE_PREFIX_REGEX = /(?:(?:coercible|nominal|params|strict)\.)?tuple(?=\<)/
+    TUPLE_MEMBERS_REGEX = /(?<=tuple<).+(?=>)/
+    TUPLE_MEMBERS_SCAN_REGEX = /(tuple\<(?:\g<1>\,)*\g<1>\>|\[(\g<1>)\](?=$)|[^,]+)(?=,|$)/
+    SUM_MATCH_REGEX = /((?:(?:\A|\|)(?:[^\|]+))*)\|([^\|]+)\z/
+
+    # @api private
+    module ReferenceHook
+      def [](name)
+        case name
+        when TUPLE_PREFIX_REGEX
+          type_map.fetch_or_store(name) do
+            key = Regexp.last_match[0]
+            types =
+              name[TUPLE_MEMBERS_REGEX].
+                scan(TUPLE_MEMBERS_SCAN_REGEX).
+                map { |(type, rest)| rest.nil? ? self[type] : [self[rest]] }
+            super(key).of(*types)
+          end
+        when SUM_MATCH_REGEX
+          type_map.fetch_or_store(name) do
+            left, right = Regexp.last_match.captures
+            self[left] | super(right)
+          end
+        else
+          super(name)
+        end
+      end
+    end
 
-    register "tuple", type
-    register "strict.tuple", type
-    register "coercible.tuple", self["nominal.tuple"].constructor(Kernel.method(:Array))
-    register "params.tuple", self["nominal.tuple"].constructor(Coercions::Params.method(:to_ary))
+    singleton_class.prepend ReferenceHook
   end
 end

data/lib/dry-types-tuple.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "dry/tuple"
+require "dry/types/tuple"

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: dry-types-tuple
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.1
 platform: ruby
 authors:
-- Anton
-autorequire:
+- Anton Semenov
 bindir: exe
 cert_chain: []
-date: 2023-02-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -96,7 +123,13 @@ files:
 - README.md
 - Rakefile
 - dry-types-tuple.gemspec
+- lib/dry-types-tuple.rb
 - lib/dry/tuple.rb
+- lib/dry/tuple/class_decorator.rb
+- lib/dry/tuple/class_interface.rb
+- lib/dry/tuple/struct.rb
+- lib/dry/tuple/type_coercer.rb
+- lib/dry/tuple/version.rb
 - lib/dry/types/tuple.rb
 homepage: https://github.com/estum/dry-types-tuple
 licenses:
@@ -106,7 +139,6 @@ metadata:
   homepage_uri: https://github.com/estum/dry-types-tuple
   source_code_uri: https://github.com/estum/dry-types-tuple
   changelog_uri: https://github.com/estum/dry-types-tuple/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -114,15 +146,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Dry::Types::Tuple
 test_files: []