dry-interface 1.0.0 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35ad221861d5f292e3b7161879eee7b19ce7153dbda2db6f99623881978e1779
-  data.tar.gz: 5d7e84b70f23f0b898292ebc9fcecb825f3c602644e393e58cb3a4f12e618c27
+  metadata.gz: 4079619043b7b01b90eb4b6def6b3c6ce28280bbb9597d0bb62ee4791fc37110
+  data.tar.gz: bef3b4af52fb863ab59402ab196f0909bffbfc3408c3898976f07d47d13c3813
 SHA512:
-  metadata.gz: ca69ef2474fc1c3aaa39f0e52183dc938dcfc3f2f7b4154a58e5e25972c807d32cd4f1b7ef69708ea7a5f6b40e7b73a9b3badbc026de9912d73e9606edc5e2fb
-  data.tar.gz: 205d5ad822c71d32561ed6875a0aeee5045278af6e8cc6cda33fe063a4712e0f3df6e4146f5c5e78d58a0cbae52317cb6240e10afdf837a2d33576ae70494896
+  metadata.gz: 8770345dae87d66406df5d677ecde817b69384d0ae1a7ebe355528d45e2800856821463349fdd262d1240231fb0f94d54f946d72b3160286087bb059b63e827b
+  data.tar.gz: dd28081ce094249862cffb93325908c90a813eac687c74f95ad91441db9493917fb84d5f15c131202542e281240b6cbf6f4ba8b31d30be61c72dc1a6fb81dd72

data/lib/dry/concrete/extensions/default.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Dry
+  class Concrete
+    module Extensions
+      module Default
+        refine Proc do
+          # @example A string type with a proc default value
+          #  Dry::Types['string'].default { 'default' }
+          #
+          # @return [#call(Dry::Types::Type)]
+          def to_default
+            -> type { type[call] }.freeze
+          end
+        end
+
+        refine Object do
+          # @example String type with default value
+          #   Dry::Types['string'].default('foo')
+          #
+          # @return [#call(Dry::Types::Type)]
+          def to_default
+            -> type = Dry::Types["any"] { type[self] }.to_default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/concrete/extensions/type.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "dry/struct"
+require "dry/types"
+
+module Dry
+  class Concrete
+    module Extensions
+      module Type
+        module Types
+          include Dry::Types()
+        end
+
+        refine String do
+          # Converts type references into types
+          #
+          # @example A strict string into a type
+          #   type = "strict.string".to_type
+          #
+          #   type.valid?("string") # => true
+          #   type.valid?(:symbol)  # => false
+          #
+          # @example A (strict) symbol into a type
+          #   type = "symbol".to_type
+          #
+          #   type.valid?(:symbol)  # => true
+          #   type.valid?("string") # => false
+          #
+          # @return [Dry::Types::Type]
+          # @raise [ArgumentError] if the type is not a valid type
+          def to_type
+            Dry::Types[self]
+          rescue Dry::Container::Error
+            raise ArgumentError, "Type reference [#{inspect}] not found in Dry::Types"
+          end
+        end
+
+        refine Object do
+          def to_type
+            raise ArgumentError, <<~ERROR
+              Cannot convert [#{inspect}] (#{self.class}) into a type using [#{inspect}#to_type]
+              Expected value of type Dry::Struct, Dry::Types or native Ruby module or class
+
+              ProTip: Replace [#{inspect}] with [Value(#{inspect})] to allow for [#{inspect}]
+
+              General examples:
+              Dry::Types:
+              Dry::Types["coercible.string"]
+              "strict.string"
+              "string"
+              Fixed values:
+              Value('undefined')
+              Value(:id)
+              Instance of class:
+              Hash
+              Array
+              String
+              [String]
+              [String, Symbol]
+              [[String, Symbol]]
+              { Symbol => Hash }
+              { Symbol => [Pathname] }
+              Constructors:
+              Struct.new(:value)
+              OpenStruct
+              Modules:
+              Enumerable
+              Comparable
+            ERROR
+          end
+        end
+
+        refine Dry::Types::Type do
+          # Dry::Types::Type is already a type in itself
+          # Used to streamline the API for all objects
+          #
+          # @example Dry type to dry type
+          #   type = Dry::Types['string'].to_type
+          #
+          #   type.valid?("string") # => true
+          #   type.valid?(:string)  # => false
+          #
+          # @return [Dry::Types::Type]
+          alias_method :to_type, :itself
+        end
+
+        refine Dry::Concrete.singleton_class do
+          # Dry::Types::Type is already a type in itself
+          # Used to streamline the API for all objects
+          #
+          # @example Dry type to dry type
+          #   type = Dry::Types['string'].to_type
+          #
+          #   type.valid?("string") # => true
+          #   type.valid?(:string)  # => false
+          #
+          # @return [Dry::Types::Type]
+          alias_method :to_type, :itself
+        end
+
+        refine Module do
+          # Ensures passed value includes module
+          #
+          # @example Check for enumerable values
+          #   type = Enumerable.to_type
+          #
+          #   type.valid?([])  # => true
+          #   type.valid?({})  # => true
+          #   type.valid?(nil) # => false
+          #
+          # @return [Dry::Types::Constrained]
+          def to_type
+            Types::Any.constrained(type: self)
+          end
+        end
+
+        refine Class do
+          # Wrapps class in a type constructor using ::new as initializer
+          #
+          # @example With a custom class
+          #   type = Struct.new(:value).to_type
+          #
+          #   type.valid?('value')            # => true
+          #   type.valid?                     # => false
+          #
+          # @example With a native Ruby class
+          #   type = String.to_type
+          #
+          #   type.valid?('value')            # => true
+          #   type.valid?(:symbol)            # => false
+          #
+          # @example With an instance of the class
+          #   Person = Struct.new(:name)
+          #
+          #   type = Person.to_type
+          #
+          #   type.valid?('value')             # => true
+          #   type.valid?(Person.new('John'))  # => true
+          #   type.valid?                      # => false
+          #
+          # @example With a class without constructor args
+          #   type = Mutex.to_type
+          #
+          #   type.valid?                      # => true
+          #   type.valid?('value')             # => false
+          #
+          # @return [Dry::Types::Constructor]
+          def to_type
+            Types.const_get(name).then do |maybe_type|
+              maybe_type == self ? to_constructor : maybe_type
+            end
+          rescue NameError, TypeError
+            to_constructor
+          end
+
+          private
+
+          def to_constructor
+            Types.Instance(self) | Types.Constructor(self, method(:new))
+          end
+        end
+
+        refine Hash do
+          # Recursively creates a hash type from {keys} & {values}
+          #
+          # @example With dynamic key and static value
+          #   type = { String => 'value' }
+          #
+          #   type.valid?('string' => 'value') # => true
+          #   type.valid?(symbol: 'value')     # => false
+          #   type.valid?('string' => 'other') # => false
+          #
+          # @example With dynamic key and value
+          #   type = { String => Enumerable }.to_type
+          #
+          #   type.valid?('string' => [])      # => true
+          #   type.valid?(symbol: [])          # => false
+          #   type.valid?('string' => :symbol) # => false
+          #
+          # @return [Dry::Types::Constrained, Dry::Types::Map]
+          def to_type
+            return Types::Hash if empty?
+
+            map { |k, v| Types::Hash.map(k.to_type, v.to_type) }.reduce(:|)
+          end
+        end
+
+        refine Array do
+          # Recursively creates an array type from {self}
+          #
+          # @example With member type
+          #   type = [String].to_type
+          #
+          #   type.valid?(['string'])            # => true
+          #   type.valid?([:symbol])             # => false
+          #
+          # @example Without member type
+          #   type = [].to_type
+          #
+          #   type.valid?(['anything'])          # => true
+          #   type.valid?('not-an-array')        # => false
+          #
+          # @example With nested members
+          #   type = [[String]].to_type
+          #
+          #   type.valid?([['string']])          # => true
+          #   type.valid?([[:symbol]])           # => false
+          #   type.valid?(['string'])            # => false
+          #
+          # @example With combined types
+          #   type = [String, Symbol].to_type
+          #
+          #   type.valid?(['string', :symbol])   # => true
+          #   type.valid?(['string'])            # => true
+          #   type.valid?([:symbol])             # => true
+          #   type.valid?([])                    # => true
+          #   type.valid?(:symbol)               # => false
+          #
+          # @return [Dry::Types::Constrained]
+          def to_type
+            return Types::Array if empty?
+
+            Types.Array(map(&:to_type).reduce(:|))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/concrete/extensions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dry
+  class Concrete
+    module Extensions
+      autoload :Default, "dry/concrete/extensions/default"
+      autoload :Type, "dry/concrete/extensions/type"
+    end
+  end
+end

data/lib/dry/concrete/value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  class Concrete
+    class Value < self
+      def self.new(value, *other, &block)
+        case value
+        in Hash => attributes then super(attributes, *other, &block)
+        in Dry::Struct => instance then instance
+        else
+          case attribute_names
+          in [] then raise ArgumentError, "[#{self}] has no attributes, one is required"
+          in [key] then super({ key => value }, *other, &block)
+          else
+            raise ArgumentError,
+                  "[#{self}] has more than one attribute: #{attribute_names.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/concrete.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/concerning"
+require "active_support/core_ext/module/delegation"
+require "active_support/descendants_tracker"
+require "active_support/configurable"
+require "active_support/inflector"
+require "active_support/concern"
+require "dry/struct"
+require "dry/types"
+
+module Dry
+  autoload :Interface, "dry/interface"
+
+  class Concrete < Dry::Struct
+    autoload :Extensions, "dry/concrete/extensions"
+    autoload :Value, "dry/concrete/value"
+    autoload :Types, "dry/interface/types"
+
+    schema schema.strict(true)
+
+    include Dry.Types(:strict, :nominal, :coercible)
+
+    extend ActiveSupport::DescendantsTracker
+    include ActiveSupport::Configurable
+    extend ActiveSupport::Inflector
+
+    using Extensions::Default
+    using Extensions::Type
+
+    config.order = Hash.new(-1)
+
+    delegate(
+      :Constructor, :Interface, :Instance, :Constant,
+      :Nominal, :Value, :Array, :Hash, :Any, to: :Types
+    )
+
+    def self.initializer(owner, &block)
+      owner.schema owner.schema.constructor(&block)
+    end
+
+    # Adds attribute {name} to the struct
+    #
+    # @example Add a new attribute
+    #   class User < Dry::Struct
+    #     attribute :name, String
+    #   end
+    #
+    # @example Add a new attribute with a default value
+    #   class User < Dry::Struct
+    #     attribute :name, String, default: "John"
+    #   end
+    #
+    # @example Add a new attribute with constraints
+    #   class User < Dry::Struct
+    #     attribute :name, String, size: 3..20
+    #   end
+    #
+    # @example Add a new attribute with array type
+    #   class User < Dry::Struct
+    #     attribute :name, [String]
+    #   end
+    #
+    # @param name [Symbol]
+    # @param constrains [Array<#to_type>]
+    # @option default [#call, Any]
+    # @return [void]
+    def self.attribute(field, *constrains, **options, &block)
+      alias_fields(field, **options) do |inner_options|
+        super(field, *build_type_from(*constrains, **inner_options, &block))
+      end
+    end
+
+    # Optional version of {#attribute}
+    #
+    # @see #attribute
+    def self.attribute?(field, *constrains, **options, &block)
+      alias_fields(field, **options) do |inner_options|
+        super(field, *build_type_from(*constrains, **inner_options, &block))
+      end
+    end
+
+    def self.alias_fields(field, aliases: [], **options, &block)
+      if options.key?(:alias)
+        aliases << options.delete(:alias)
+      end
+
+      block[options]
+
+      aliases.each do |alias_name|
+        alias_method alias_name, field
+      end
+    end
+
+    # @api private
+    def self.build_type_from(*constrains, **options, &block)
+      if block_given?
+        return [Class.new(Concrete, &block)]
+      end
+
+      unless (type = constrains.map(&:to_type).reduce(:|))
+        return EMPTY_ARRAY
+      end
+
+      if options.key?(:default)
+        options.delete(:default).to_default.then do |default_proc|
+          return build_type_from(type.default(&default_proc), **options)
+        end
+      end
+
+      if options.empty?
+        return [type]
+      end
+
+      build_type_from(type.constrained(**options))
+    end
+  end
+end

data/lib/dry/interface/interfaces/abstract.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/attribute_accessors"
+
 module Dry
   class Interface
     module Interfaces
       module Abstract
         extend ActiveSupport::Concern
-        include Common
 
         class_methods do
-          def type
-            direct_descendants.map(&:type).reduce(&:|) or raise "No types defined for [#{self}]"
+          # Class name without parent module
+          #
+          # @return [String]
+          def name
+            demodulize(super)
           end
 
-          def named
-            format "%<name>s<[%<names>s]>", { name: name, names: direct_descendants.map(&:named).join(" | ") }
+          def new(input, safe = false, &block)
+            if safe
+              call_safe(input, &block)
+            else
+              call_unsafe(input)
+            end
           end
         end
       end

data/lib/dry/interface/interfaces/concrete.rb

@@ -1,25 +1,45 @@
 # frozen_string_literal: true
 
+# module C
+#   def structs
+#     [self]
+#   end
+
+#   def named
+#     to_s
+#   end
+
+#   def type
+#     self
+#   end
+# end
+
 module Dry
   class Interface
     module Interfaces
       module Concrete
         extend ActiveSupport::Concern
-        include Common
 
-        included do
+        prepended do
           class << self
+            alias_method :call_safe, :_call_safe
+            alias_method :call_unsafe, :_call_unsafe
             alias_method :new, :_new
+            alias_method :call, :_call
           end
         end
+        # included do
+        #   class << self
+        #     alias_method :call, :_call
+        #   end
+        # end
 
         class_methods do
-          def type
-            direct_descendants.first or self
-          end
-
-          def named
-            direct_descendants.first&.name or name
+          # Class name without parent module
+          #
+          # @return [String]
+          def to_s
+            demodulize(name)
           end
         end
       end

data/lib/dry/interface/interfaces/unit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Interfaces
+      module Unit
+        extend ActiveSupport::Concern
+
+        prepended do
+          class << self
+            alias_method :call, :_call
+            alias_method :call_unsafe, :_call_unsafe
+            alias_method :call_safe, :_call_safe
+          end
+        end
+
+        class_methods do
+          # Class name without parent module
+          #
+          # @return [String]
+          def to_s
+            demodulize(name)
+          end
+
+          # Allows a struct to be called without a hash
+          #
+          # @param value [Dry::Struct, Hash, Any]
+          # @param block [Proc]
+          #
+          # @return [Dry::Struct]
+
+          def new(value, *other, &block)
+            case value
+            in Hash => attributes then _new(attributes, *other, &block)
+            in Dry::Struct => instance then instance
+            else
+              case attribute_names
+              in [] then raise ArgumentError, "[#{self}] has no attributes, one is required"
+              in [key] then _new({ key => value }, *other, &block)
+              else
+                raise ArgumentError,
+                      "[#{self}] has more than one attribute: #{attribute_names.join(', ')}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/interface/interfaces.rb

@@ -3,8 +3,7 @@
 module Dry
   class Interface
     module Interfaces
-      autoload :Value, "dry/interface/interfaces/value"
-      autoload :Common, "dry/interface/interfaces/common"
+      autoload :Unit, "dry/interface/interfaces/unit"
       autoload :Abstract, "dry/interface/interfaces/abstract"
       autoload :Concrete, "dry/interface/interfaces/concrete"
     end

data/lib/dry/interface/patch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Patch
+      autoload :Value, "dry/interface/patch/value"
+      autoload :Abstract, "dry/interface/patch/abstract"
+      autoload :Concrete, "dry/interface/patch/concrete"
+    end
+  end
+end

data/lib/dry/interface/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Types
+      include Dry.Types(:strict, :nominal, :coercible)
+    end
+  end
+end

data/lib/dry/interface.rb

@@ -6,74 +6,119 @@ require "active_support/descendants_tracker"
 require "active_support/configurable"
 require "active_support/inflector"
 require "active_support/concern"
-require "dry/struct"
 require "dry/types"
+require "dry"
 
 module Dry
-  class Interface < Dry::Struct
+  autoload :Concrete, "dry/concrete"
+
+  class Interface < Concrete
     autoload :Interfaces, "dry/interface/interfaces"
-    autoload :VERSION, "dry/interface/version"
 
-    extend ActiveSupport::DescendantsTracker
-    extend ActiveSupport::Inflector
+    include ActiveSupport::Configurable
 
-    schema schema.strict(true)
+    config.order = Hash.new(-1)
 
-    concerning :New, prepend: true do
-      prepended do
-        class << self
-          alias_method :_new, :new
-        end
-      end
-    end
+    class << self
+      alias _new new
+      alias _call call
+      alias _call_safe call_safe
+      alias _call_unsafe call_unsafe
 
-    module Types
-      include Dry.Types()
+      delegate :call, to: :subtype
+      delegate :call_safe, to: :subtype
+      delegate :call_unsafe, to: :subtype
     end
 
-    def self.Value(...)
-      Types.Value(...)
-    end
+    # Allow types structs to be ordered
+    #
+    # @param names [Array<Symbol>]
+    def self.order(*names)
+      result = names.each_with_index.reduce(EMPTY_HASH) do |acc, (name, index)|
+        acc.merge(name.to_s => index)
+      end
 
-    def self.type
-      direct_descendants.map(&:type).reduce(&:|)
+      config.order = result
     end
 
-    def self.named
-      format "%<name>s<[%<names>s]>", { name: name, names: direct_descendants.map(&:named).join(" | ") }
+    # @return [String]
+    def self.to_s
+      "%s<[%s]>" % [name, subtypes.map(&:to_s).join(" | ")]
     end
 
-    def self.new(...)
-      type.call(...)
+    def self.reduce(input, subtype)
+      case input
+      in { result: }
+        input
+      in { value: }
+        { result: subtype.call(value) }
+      end
+    rescue Dry::Struct::Error => e
+      em = Dry::Types::ConstraintError.new(e.message, input.fetch(:value))
+      input.merge(errors: input.fetch(:errors, []) + [em])
+    rescue Dry::Types::CoercionError => e
+      input.merge(errors: input.fetch(:errors, []) + [e])
     end
 
-    def self.initializer(owner, &block)
-      owner.schema owner.schema.constructor(&block)
+    # Internal type represented by {self}
+    #
+    # @return [Dry::Struct::Sum, Dry::Struct::Class]
+    def self.subtype
+      Constructor(self) do |value, _type, &error|
+        error ||= -> error do
+          raise error
+        end
+
+        if subtypes.empty?
+          raise NotImplementedError, "No subtypes defined for #{name}"
+        end
+
+        output = subtypes.reduce({ value: value }, &method(:reduce))
+
+        case output
+        in { result: }
+          result
+        in { errors: }
+          error[Dry::Types::MultipleError.new(errors)]
+        in Dry::Struct
+          output
+        end
+      end
     end
 
-    def self.otherwise(&block)
-      initializer(self) do |input, type, &error|
-        type[input] { block[input, type, &error] }
+    # Internal types represented by {self}
+    #
+    # @return [Dry::Struct::Class]
+    def self.subtypes
+      types = subclasses.flat_map(&:subclasses)
+
+      return types if config.order.empty?
+
+      types.sort_by do |type|
+        config.order.fetch(demodulize(type.name))
       end
     end
 
+    # @param name [Symbol]
+    #
+    # @return [Abstract::Class]
     def self.const_missing(name)
       case name
-      when :Abstract
-        return Class.new(self) do
-          include Interfaces::Abstract
+      in :Concrete
+        Class.new(self) do
+          prepend Interfaces::Concrete
         end
-      when :Concrete
-        return Class.new(self) do
-          include Interfaces::Concrete
+      in :Abstract
+        Class.new(self) do
+          prepend Interfaces::Abstract
         end
-      when :Value
-        return Class.new(self) do
-          include Interfaces::Value
+      in :Unit
+        Class.new(self) do
+          prepend Interfaces::Unit
         end
+      else
+        super
       end
-
-      super
     end
   end
 end

data/lib/dry/value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  class Value < Dry::Struct
+    schema schema.strict(true)
+
+    def self.new(value, *other, &block)
+      case value
+      in Hash => attributes then super(attributes, *other, &block)
+      in Dry::Struct => instance then instance
+      else
+        case attribute_names
+        in [] then raise ArgumentError, "[#{self}] has no attributes, one is required"
+        in [key] then super({ key => value }, *other, &block)
+        else
+          raise ArgumentError,
+                "[#{self}] has more than one attribute: #{attribute_names.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/dry.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dry
+  autoload :Value, "dry/value"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-interface
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.4
 platform: ruby
 authors:
 - Linus Oleander
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-21 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,12 +59,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/dry.rb
+- lib/dry/concrete.rb
+- lib/dry/concrete/extensions.rb
+- lib/dry/concrete/extensions/default.rb
+- lib/dry/concrete/extensions/type.rb
+- lib/dry/concrete/value.rb
 - lib/dry/interface.rb
 - lib/dry/interface/interfaces.rb
 - lib/dry/interface/interfaces/abstract.rb
-- lib/dry/interface/interfaces/common.rb
 - lib/dry/interface/interfaces/concrete.rb
-- lib/dry/interface/interfaces/value.rb
+- lib/dry/interface/interfaces/unit.rb
+- lib/dry/interface/patch.rb
+- lib/dry/interface/types.rb
+- lib/dry/value.rb
 homepage: https://github.com/oleander/dry-interface
 licenses:
 - MIT
@@ -78,14 +86,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: Dry::Interface

data/lib/dry/interface/interfaces/common.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  class Interface
-    module Interfaces
-      module Common
-        extend ActiveSupport::Concern
-
-        class_methods do
-          def name
-            demodulize(super)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dry/interface/interfaces/value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  class Interface
-    module Interfaces
-      module Value
-        extend ActiveSupport::Concern
-        include Concrete
-
-        included do |child|
-          otherwise do |value, type, &error|
-            names = child.type.attribute_names
-
-            unless names.one?
-              raise ArgumentError, "Value classes must have exactly one attribute, got [#{names.join(', ')}] (#{names.count}) for [#{child}]"
-            end
-
-            type[names.first => value, &error]
-          end
-        end
-      end
-    end
-  end
-end