dry-types 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db688f074a70acff2e5acd2b23ad2dd14d5292fe
-  data.tar.gz: e148638d952426127fd886ee25bad640cf8d7839
+  metadata.gz: 02e8392346549c5801d50d1fb805951bea41e722
+  data.tar.gz: 6e4873ce2f3f8f92eb1bbbfccfbe68aed67524c2
 SHA512:
-  metadata.gz: 3e1dc84f874a91638488e15eff1dbd0f97a3ee6b25cd0ecf7deab7300441382f9b05912830cab13570ced7840e5030aec17175fd6cfee6ce27c12b386ba4bcf9
-  data.tar.gz: 6eaf193a169e9a4e951657dbae09272098ee369ccc9c6e08b730d9d486e9ee94c71ea05e59b14cd3925919ebe0a480402f8e12f35037cfa5a21392754d2854cc
+  metadata.gz: 1153d031efd2277c552a3b47e26395da775d5fa70600bc815c9f1a4658cb8200ba99c595b90c52c8128bd896bb017f2bcd1a0fcf80227bbb57118d2a1305f03d
+  data.tar.gz: 0d6c974e7bf9fbb552d4abd95e15a51368685507e21eda31909c9b002c43652dd74c08244728242330797be64e5b196bc7f1763c91d204f6b51ad181d69f65a1

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+# v0.7.0 2016-03-30
+
+Major focus of this release is to make complex type composition possible and improving constraint errors to be more meaningful.
+
+## Added
+
+- `Type#try` interface that tries to process the input and return a result object which can be either a success or failure (solnic)
+- `#meta` interface for setting arbitrary meta data on types (solnic)
+- `ConstraintError` has a message which includes information about the predicate which failed ie `nil violates constraints (type?(String) failed)` (solnic)
+- `Struct` uses `Dry::Equalizer` too, just like `Value` (AMHOL)
+- `Sum::Constrained` which has a disjunction rule built from its types (solnic)
+- Compiler supports `[:constructor, [primitive, fn_proc]]` nodes (solnic)
+- Compiler supports building schema-less `form.hash` types (solnic)
+
+## Fixed
+
+- `Sum` now supports complex types like `Array` or `Hash` with member types and/or constraints (solnic)
+- `Default#constrained` will properly wrap a new constrained type (solnic)
+
+## Changed
+
+- [BREAKING] Renamed `Type#{optional=>maybe}` (AMHOL)
+- [BREAKING] `Type#optional(other)` builds a sum: `Strict::Nil | other` (AMHOL)
+- [BREAKING] Type objects are now frozen (solnic)
+- [BREAKING] `Value` instances are frozen (AMHOL)
+- `Array` is no longer a constructor and has a `Array::Member` subclass (solnic)
+- `Hash` is no longer a constructor and is split into `Hash::Safe`, `Hash::Strict` and `Hash::Symbolized` (solnic)
+- `Constrained` has now a `Constrained::Coercible` subclass which will try to apply its type prior applying its rule (solnic)
+- `#maybe` uses `Strict::Nil` now (solnic)
+- `Type#default` will raise if `nil` was passed for `Maybe` type (solnic)
+- `Hash` with a schema will set maybe values for missing keys or nils (flash-gordon)
+
+[Compare v0.6.0...v0.7.0](https://github.com/dryrb/dry-types/compare/v0.6.0...v0.7.0)
+
 # v0.6.0 2016-03-16
 
 Renamed from `dry-data` to `dry-types` and:

data/Gemfile

@@ -8,6 +8,8 @@ end
 
 group :tools do
   gem 'byebug', platform: :mri
+  gem 'mutant'
+  gem 'mutant-rspec'
 end
 
 group :benchmarks do

data/dry-types.gemspec

@@ -27,15 +27,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'thread_safe', '~> 0.3'
-  spec.add_runtime_dependency 'dry-container', '~> 0.2'
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_runtime_dependency 'dry-container', '~> 0.3'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
   spec.add_runtime_dependency 'dry-logic', '~> 0.2', '>= 0.2.0'
   spec.add_runtime_dependency 'inflecto', '~> 0.0.0', '>= 0.0.2'
   spec.add_runtime_dependency 'kleisli', '~> 0.2'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 11.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 end

data/lib/dry/types.rb

@@ -3,7 +3,7 @@ require 'date'
 require 'set'
 
 require 'inflecto'
-require 'thread_safe'
+require 'concurrent'
 
 require 'dry-container'
 require 'dry-equalizer'
@@ -15,27 +15,14 @@ require 'dry/types/constructor'
 require 'dry/types/struct'
 require 'dry/types/value'
 
+require 'dry/types/errors'
+
 module Dry
   module Types
     extend Dry::Configurable
 
     setting :namespace, self
 
-    class SchemaError < TypeError
-      def initialize(key, value)
-        super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
-      end
-    end
-
-    class SchemaKeyError < KeyError
-      def initialize(key)
-        super(":#{key} is missing in Hash input")
-      end
-    end
-
-    StructError = Class.new(TypeError)
-    ConstraintError = Class.new(TypeError)
-
     TYPE_SPEC_REGEX = %r[(.+)<(.+)>].freeze
 
     def self.module
@@ -103,7 +90,7 @@ module Dry
     end
 
     def self.type_map
-      @type_map ||= ThreadSafe::Cache.new
+      @type_map ||= Concurrent::Map.new
     end
 
     def self.type_keys

data/lib/dry/types/array.rb

@@ -0,0 +1,17 @@
+require 'dry/types/array/member'
+
+module Dry
+  module Types
+    class Array < Definition
+      def member(type)
+        member =
+          case type
+          when String, Class then Types[type]
+          else type
+          end
+
+        Array::Member.new(primitive, options.merge(member: member))
+      end
+    end
+  end
+end

data/lib/dry/types/array/member.rb

@@ -0,0 +1,30 @@
+module Dry
+  module Types
+    class Array < Definition
+      class Member < Array
+        attr_reader :member
+
+        def initialize(primitive, options = {})
+          @member = options.fetch(:member)
+          super
+        end
+
+        def call(input, meth = :call)
+          input.map { |el| member.__send__(meth, el) }
+        end
+        alias_method :[], :call
+
+        def try(input, &block)
+          result = call(input, :try)
+
+          if result.all?(&:success?)
+            success(result.map(&:input))
+          else
+            failure = failure(input, result.select(&:failure?))
+            block ? yield(failure) : failure
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/builder.rb

@@ -1,16 +1,25 @@
 module Dry
   module Types
     module Builder
+      def constrained_type
+        Constrained
+      end
+
       def |(other)
-        Sum.new(self, other)
+        klass = is_a?(Constrained) && other.is_a?(Constrained) ? Sum::Constrained : Sum
+        klass.new(self, other)
       end
 
       def optional
-        Optional.new(Types['nil'] | self)
+        Types['strict.nil'] | self
+      end
+
+      def maybe
+        Maybe.new(Types['strict.nil'] | self)
       end
 
       def constrained(options)
-        Constrained.new(self, rule: Types.Rule(options))
+        constrained_type.new(self, rule: Types.Rule(options))
       end
 
       def default(input = nil, &block)
@@ -31,8 +40,8 @@ module Dry
         Safe.new(self)
       end
 
-      def constructor(constructor, options = {})
-        Constructor.new(with(options), fn: constructor)
+      def constructor(constructor = nil, **options, &block)
+        Constructor.new(with(options), fn: constructor || block)
       end
     end
   end
@@ -41,6 +50,6 @@ end
 require 'dry/types/default'
 require 'dry/types/constrained'
 require 'dry/types/enum'
-require 'dry/types/optional'
+require 'dry/types/maybe'
 require 'dry/types/safe'
 require 'dry/types/sum'

data/lib/dry/types/coercions/form.rb

@@ -1,6 +1,7 @@
 require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util'
+require 'time'
 
 module Dry
   module Types
@@ -8,7 +9,7 @@ module Dry
       module Form
         TRUE_VALUES = %w[1 on  t true  y yes].freeze
         FALSE_VALUES = %w[0 off f false n no].freeze
-        BOOLEAN_MAP = Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
+        BOOLEAN_MAP = ::Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
 
         def self.to_nil(input)
           if input.is_a?(String) && input == ''

data/lib/dry/types/compiler.rb

@@ -15,6 +15,11 @@ module Dry
         send(:"visit_#{node[0]}", node[1], *args)
       end
 
+      def visit_constructor(node)
+        primitive, fn = node
+        Types::Constructor.new(primitive, &fn)
+      end
+
       def visit_type(node)
         type, args = node
         meth = :"visit_#{type.tr('.', '_')}"
@@ -44,8 +49,12 @@ module Dry
       end
 
       def visit_form_hash(node)
-        constructor, schema = node
-        merge_with('form.hash', constructor, schema)
+        if node
+          constructor, schema = node
+          merge_with('form.hash', constructor, schema)
+        else
+          registry['form.hash']
+        end
       end
 
       def visit_key(node)

data/lib/dry/types/constrained.rb

@@ -1,5 +1,6 @@
 require 'dry/types/decorator'
 require 'dry/types/constraints'
+require 'dry/types/constrained/coercible'
 
 module Dry
   module Types
@@ -15,22 +16,24 @@ module Dry
       end
 
       def call(input)
-        result = try(input)
-
-        if valid?(result)
-          result
-        else
-          raise ConstraintError, "#{input.inspect} violates constraints"
-        end
+        try(input) do |result|
+          raise ConstraintError, result
+        end.input
       end
       alias_method :[], :call
 
-      def try(input)
-        type[input]
+      def try(input, &block)
+        validation = rule.(input)
+
+        if validation.success?
+          type.try(input, &block)
+        else
+          block ? yield(validation) : validation
+        end
       end
 
-      def valid?(input)
-        rule.(input).success?
+      def valid?(value)
+        rule.(value).success?
       end
 
       def constrained(options)

data/lib/dry/types/constrained/coercible.rb

@@ -0,0 +1,23 @@
+module Dry
+  module Types
+    class Constrained
+      class Coercible < Constrained
+        def try(input, &block)
+          result = type.try(input)
+
+          if result.success?
+            validation = rule.(result.input)
+
+            if validation.success?
+              result
+            else
+              block ? yield(validation) : validation
+            end
+          else
+            block ? yield(result) : result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/constructor.rb

@@ -5,21 +5,19 @@ module Dry
     class Constructor < Definition
       include Dry::Equalizer(:type)
 
-      undef_method :primitive
-
       attr_reader :fn
 
       attr_reader :type
 
-      def self.new(input, options = {})
-        type = input.is_a?(Definition) ? input : Definition.new(input)
-        super(type, options)
+      def self.new(input, options = {}, &block)
+        type = input.is_a?(Builder) ? input : Definition.new(input)
+        super(type, options, &block)
       end
 
-      def initialize(type, options = {})
-        super
+      def initialize(type, options = {}, &block)
         @type = type
-        @fn = options.fetch(:fn)
+        @fn = options.fetch(:fn, block)
+        super
       end
 
       def primitive
@@ -27,26 +25,43 @@ module Dry
       end
 
       def call(input)
-        fn[input]
+        type[fn[input]]
       end
       alias_method :[], :call
 
-      def constructor(new_fn, options = {})
-        with(options.merge(fn: -> input { new_fn[fn[input]] }))
+      def try(input, &block)
+        type.try(fn[input], &block)
+      rescue TypeError => e
+        failure(input, e.message)
       end
 
-      def respond_to_missing?(meth, include_private = false)
-        super || type.respond_to?(meth)
+      def constructor(new_fn = nil, **options, &block)
+        left = new_fn || block
+        right = fn
+
+        with(options.merge(fn: -> input { left[right[input]] }))
+      end
+
+      def valid?(value)
+        super && type.valid?(value)
+      end
+
+      def constrained_type
+        Constrained::Coercible
       end
 
       private
 
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
           response = type.__send__(meth, *args, &block)
 
-          if response.is_a?(Constructor)
-            constructor(response.fn, options.merge(response.options))
+          if response.kind_of?(Builder)
+            self.class.new(response, options)
           else
             response
           end

data/lib/dry/types/core.rb

@@ -5,8 +5,8 @@ module Dry
       int: Integer,
       float: Float,
       decimal: BigDecimal,
-      array: Array,
-      hash: Hash
+      array: ::Array,
+      hash: ::Hash
     }.freeze
 
     NON_COERCIBLE = {
@@ -40,12 +40,23 @@ module Dry
     # Register non-coercible maybe types
     ALL_PRIMITIVES.each_key do |name|
       next if name == :nil
-      register("maybe.strict.#{name}", self["strict.#{name}"].optional)
+      register("maybe.strict.#{name}", self["strict.#{name}"].maybe)
     end
 
     # Register coercible maybe types
     COERCIBLE.each_key do |name|
-      register("maybe.coercible.#{name}", self["coercible.#{name}"].optional)
+      register("maybe.coercible.#{name}", self["coercible.#{name}"].maybe)
+    end
+
+    # Register non-coercible optional types
+    ALL_PRIMITIVES.each_key do |name|
+      next if name == :nil
+      register("optional.strict.#{name}", self["strict.#{name}"].optional)
+    end
+
+    # Register coercible optional types
+    COERCIBLE.each_key do |name|
+      register("optional.coercible.#{name}", self["coercible.#{name}"].optional)
     end
 
     # Register :bool since it's common and not a built-in Ruby type :(

data/lib/dry/types/decorator.rb

@@ -12,16 +12,16 @@ module Dry
         type.constructor
       end
 
-      def valid?(input)
-        type.valid?(input)
+      def with(new_options)
+        self.class.new(type, options.merge(new_options))
       end
 
-      def respond_to_missing?(meth, include_private = false)
-        super || type.respond_to?(meth)
+      def valid?(value)
+        type.valid?(value)
       end
 
-      def with(new_options)
-        self.class.new(type, options.merge(new_options))
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
       end
 
       private

data/lib/dry/types/default.rb

@@ -29,6 +29,10 @@ module Dry
         @value = options.fetch(:value)
       end
 
+      def constrained(*args)
+        type.constrained(*args).default(value)
+      end
+
       def call(input)
         if input.nil?
           evaluate

data/lib/dry/types/definition.rb

@@ -1,9 +1,12 @@
 require 'dry/types/builder'
+require 'dry/types/result'
+require 'dry/types/options'
 
 module Dry
   module Types
     class Definition
       include Dry::Equalizer(:primitive, :options)
+      include Options
       include Builder
 
       attr_reader :options
@@ -12,21 +15,18 @@ module Dry
 
       def self.[](primitive)
         if primitive == ::Array
-          Definition::Array
+          Types::Array
         elsif primitive == ::Hash
-          Definition::Hash
+          Types::Hash
         else
           self
         end
       end
 
       def initialize(primitive, options = {})
+        super
         @primitive = primitive
-        @options = options
-      end
-
-      def with(new_options)
-        self.class.new(primitive, options.merge(new_options))
+        freeze
       end
 
       def name
@@ -38,16 +38,36 @@ module Dry
       end
       alias_method :[], :call
 
-      def try(input)
-        call(input)
+      def try(input, &block)
+        output = call(input)
+
+        if valid?(output)
+          success(output)
+        else
+          failure = failure(output, "#{output.inspect} must be an instance of #{primitive}")
+          block ? yield(failure) : failure
+        end
+      end
+
+      def success(*args)
+        result(Result::Success, *args)
+      end
+
+      def failure(*args)
+        result(Result::Failure, *args)
+      end
+
+      def result(klass, *args)
+        klass.new(*args)
       end
 
-      def valid?(input)
-        input.is_a?(primitive)
+      def primitive?(value)
+        value.is_a?(primitive)
       end
+      alias_method :valid?, :primitive?
     end
   end
 end
 
-require 'dry/types/definition/array'
-require 'dry/types/definition/hash'
+require 'dry/types/array'
+require 'dry/types/hash'

data/lib/dry/types/errors.rb

@@ -0,0 +1,47 @@
+module Dry
+  module Types
+    extend Dry::Configurable
+
+    setting :namespace, self
+
+    class SchemaError < TypeError
+      def initialize(key, value)
+        super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
+      end
+    end
+
+    class SchemaKeyError < KeyError
+      def initialize(key)
+        super(":#{key} is missing in Hash input")
+      end
+    end
+
+    StructError = Class.new(TypeError)
+
+    ConstraintError = Class.new(TypeError) do
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+        if result.is_a?(String)
+          super
+        else
+          super("#{result.input.inspect} violates constraints (#{failure_message})")
+        end
+      end
+
+      def input
+        result.input
+      end
+
+      def failure_message
+        if result.respond_to?(:rule)
+          rule = result.rule
+          "#{rule.predicate.id}(#{rule.predicate.args.map(&:inspect).join(', ')}) failed"
+        else
+          result.inspect
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/form.rb

@@ -27,7 +27,7 @@ module Dry
     end
 
     register('form.bool') do
-      self['form.true'] | self['form.false']
+      (self['form.true'] | self['form.false']).safe
     end
 
     register('form.int') do

data/lib/dry/types/hash.rb

@@ -0,0 +1,27 @@
+require 'dry/types/hash/schema'
+
+module Dry
+  module Types
+    class Hash < Definition
+      def schema(type_map, klass = Safe)
+        member_types = type_map.each_with_object({}) { |(name, type), result|
+          result[name] =
+            case type
+            when String, Class then Types[type]
+            else type
+            end
+        }
+
+        klass.new(primitive, options.merge(member_types: member_types))
+      end
+
+      def strict(type_map)
+        schema(type_map, Strict)
+      end
+
+      def symbolized(type_map)
+        schema(type_map, Symbolized)
+      end
+    end
+  end
+end

data/lib/dry/types/hash/schema.rb

@@ -0,0 +1,83 @@
+module Dry
+  module Types
+    class Hash < Definition
+      class Schema < Hash
+        attr_reader :member_types
+
+        def initialize(primitive, options = {})
+          @member_types = options.fetch(:member_types)
+          super
+        end
+
+        def try(hash, &block)
+          result = call(hash, :try)
+
+          if result.values.all?(&:success?)
+            success(result.each_with_object({}) { |(key, res), h| h[key] = res.input })
+          else
+            failure = failure(hash, result)
+            block ? yield(failure) : failure
+          end
+        end
+
+        private
+
+        def resolve_missing_value(result, key, type)
+          if type.is_a?(Default)
+            result[key] = type.evaluate
+          elsif type.is_a?(Maybe)
+            result[key] = type[nil]
+          end
+        end
+      end
+
+      class Safe < Schema
+        def call(hash, meth = :call)
+          member_types.each_with_object({}) do |(key, type), result|
+            if hash.key?(key)
+              result[key] = type.__send__(meth, hash[key])
+            else
+              resolve_missing_value(result, key, type)
+            end
+          end
+        end
+        alias_method :[], :call
+      end
+
+      class Symbolized < Schema
+        def call(hash, meth = :call)
+          member_types.each_with_object({}) do |(key, type), result|
+            if hash.key?(key)
+              result[key] = type.__send__(meth, hash[key])
+            else
+              key_name = key.to_s
+
+              if hash.key?(key_name)
+                result[key] = type.__send__(meth, hash[key_name])
+              else
+                resolve_missing_value(result, key, type)
+              end
+            end
+          end
+        end
+        alias_method :[], :call
+      end
+
+      class Strict < Schema
+        def call(hash, meth = :call)
+          member_types.each_with_object({}) do |(key, type), result|
+            begin
+              value = hash.fetch(key)
+              result[key] = type.__send__(meth, value)
+            rescue TypeError
+              raise SchemaError.new(key, value)
+            rescue KeyError
+              raise SchemaKeyError.new(key)
+            end
+          end
+        end
+        alias_method :[], :call
+      end
+    end
+  end
+end

data/lib/dry/types/{optional.rb → maybe.rb}

@@ -3,7 +3,7 @@ require 'dry/types/decorator'
 
 module Dry
   module Types
-    class Optional
+    class Maybe
       include Decorator
       include Builder
 
@@ -11,6 +11,14 @@ module Dry
         input.is_a?(Kleisli::Maybe) ? input : Maybe(type[input])
       end
       alias_method :[], :call
+
+      def default(value)
+        if value.nil?
+          raise ArgumentError, "nil cannot be used as a default of an optional type"
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/dry/types/options.rb

@@ -0,0 +1,23 @@
+module Dry
+  module Types
+    module Options
+      attr_reader :options
+
+      attr_reader :meta
+
+      def initialize(*args, **options )
+        @__args__ = args
+        @options = options
+        @meta = options.fetch(:meta, {})
+      end
+
+      def with(new_options)
+        self.class.new(*@__args__, options.merge(new_options))
+      end
+
+      def meta(data = nil)
+        data ? with(meta: data) : @meta
+      end
+    end
+  end
+end

data/lib/dry/types/result.rb

@@ -0,0 +1,25 @@
+module Dry
+  module Types
+    module Result
+      class Success < Struct.new(:input)
+        def success?
+          true
+        end
+
+        def failure?
+          false
+        end
+      end
+
+      class Failure < Struct.new(:input, :error)
+        def success?
+          false
+        end
+
+        def failure?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/safe.rb

@@ -7,14 +7,20 @@ module Dry
       include Builder
 
       def call(input)
-        if input.is_a?(primitive)
-          type.call(input)
+        if type.primitive?(input) || type.is_a?(Sum) || type.is_a?(Constructor)
+          type[input]
         else
           input
         end
+      rescue TypeError
+        input
       end
       alias_method :[], :call
 
+      def try(input, &block)
+        type.try(input, &block)
+      end
+
       private
 
       def decorate?(response)

data/lib/dry/types/struct.rb

@@ -7,7 +7,18 @@ module Dry
 
       def self.inherited(klass)
         super
-        Types.register_class(klass) unless klass == Value
+
+        klass.instance_variable_set('@equalizer', Equalizer.new)
+        klass.send(:include, klass.equalizer)
+
+        unless klass == Value
+          klass.instance_variable_set('@constructor', Types['coercible.hash'])
+          Types.register_class(klass)
+        end
+      end
+
+      def self.equalizer
+        @equalizer
       end
 
       def self.attribute(name, type)
@@ -21,6 +32,7 @@ module Dry
         @constructor = Types['coercible.hash'].public_send(constructor_type, schema)
 
         attr_reader(*(new_schema.keys - prev_schema.keys))
+        equalizer.instance_variable_get('@keys').concat(schema.keys).uniq!
 
         self
       end

data/lib/dry/types/sum.rb

@@ -1,14 +1,25 @@
+require 'dry/types/options'
+
 module Dry
   module Types
     class Sum
       include Builder
+      include Options
 
       attr_reader :left
 
       attr_reader :right
 
-      def initialize(left, right)
+      class Constrained < Sum
+        def rule
+          left.rule | right.rule
+        end
+      end
+
+      def initialize(left, right, options = {})
+        super
         @left, @right = left, right
+        freeze
       end
 
       def name
@@ -16,18 +27,32 @@ module Dry
       end
 
       def call(input)
-        value = left.try(input)
+        try(input) do |result|
+          raise ConstraintError, result
+        end.input
+      end
+      alias_method :[], :call
 
-        if left.valid?(value)
-          value
+      def try(input, &block)
+        result = left.try(input) do
+          right.try(input)
+        end
+
+        return result if result.success?
+
+        if block
+          yield(result)
         else
-          right[value]
+          result
         end
       end
-      alias_method :[], :call
 
-      def valid?(input)
-        left.valid?(input) || right.valid?(input)
+      def primitive?(value)
+        left.primitive?(value) || right.primitive?(value)
+      end
+
+      def valid?(value)
+        left.valid?(value) || right.valid?(value)
       end
     end
   end

data/lib/dry/types/value.rb

@@ -3,19 +3,8 @@ require 'dry/types/struct'
 module Dry
   module Types
     class Value < Struct
-      def self.inherited(klass)
-        super
-        klass.instance_variable_set('@equalizer', Equalizer.new)
-        klass.send(:include, klass.equalizer)
-      end
-
-      def self.attributes(*args)
-        super
-        equalizer.instance_variable_get('@keys').concat(schema.keys).uniq!
-      end
-
-      def self.equalizer
-        @equalizer
+      def self.new(*, &_block)
+        super.freeze
       end
     end
   end

data/lib/dry/types/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Types
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: dry-types
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-16 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thread_safe
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dry-container
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
   requirement: !ruby/object:Gem::Requirement
@@ -126,28 +126,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -185,10 +185,13 @@ files:
 - dry-types.gemspec
 - lib/dry-types.rb
 - lib/dry/types.rb
+- lib/dry/types/array.rb
+- lib/dry/types/array/member.rb
 - lib/dry/types/builder.rb
 - lib/dry/types/coercions/form.rb
 - lib/dry/types/compiler.rb
 - lib/dry/types/constrained.rb
+- lib/dry/types/constrained/coercible.rb
 - lib/dry/types/constraints.rb
 - lib/dry/types/constructor.rb
 - lib/dry/types/container.rb
@@ -196,11 +199,14 @@ files:
 - lib/dry/types/decorator.rb
 - lib/dry/types/default.rb
 - lib/dry/types/definition.rb
-- lib/dry/types/definition/array.rb
-- lib/dry/types/definition/hash.rb
 - lib/dry/types/enum.rb
+- lib/dry/types/errors.rb
 - lib/dry/types/form.rb
-- lib/dry/types/optional.rb
+- lib/dry/types/hash.rb
+- lib/dry/types/hash/schema.rb
+- lib/dry/types/maybe.rb
+- lib/dry/types/options.rb
+- lib/dry/types/result.rb
 - lib/dry/types/safe.rb
 - lib/dry/types/struct.rb
 - lib/dry/types/sum.rb
@@ -227,7 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Type system for Ruby supporting coercions, constraints and complex types

data/lib/dry/types/definition/array.rb

@@ -1,24 +0,0 @@
-module Dry
-  module Types
-    class Definition
-      class Array < Definition
-        def self.constructor(member_constructor, array)
-          array.map { |value| member_constructor[value] }
-        end
-
-        def member(type)
-          member_constructor =
-            case type
-            when String, Class then Types[type]
-            else type
-            end
-
-          array_constructor = self.class
-            .method(:constructor).to_proc.curry.(member_constructor)
-
-          constructor(array_constructor, member: member_constructor)
-        end
-      end
-    end
-  end
-end

data/lib/dry/types/definition/hash.rb

@@ -1,68 +0,0 @@
-module Dry
-  module Types
-    class Definition
-      class Hash < Definition
-        def self.safe_constructor(types, hash)
-          types.each_with_object({}) do |(key, type), result|
-            if hash.key?(key)
-              result[key] = type[hash[key]]
-            elsif type.is_a?(Default)
-              result[key] = type.evaluate
-            end
-          end
-        end
-
-        def self.symbolized_constructor(types, hash)
-          types.each_with_object({}) do |(key, type), result|
-            if hash.key?(key)
-              result[key] = type[hash[key]]
-            else
-              key_name = key.to_s
-
-              if hash.key?(key_name)
-                result[key] = type[hash[key_name]]
-              elsif type.is_a?(Default)
-                result[key] = type.evaluate
-              end
-            end
-          end
-        end
-
-        def self.strict_constructor(types, hash)
-          types.each_with_object({}) do |(key, type), result|
-            begin
-              value = hash.fetch(key)
-              result[key] = type[value]
-            rescue TypeError
-              raise SchemaError.new(key, value)
-            rescue KeyError
-              raise SchemaKeyError.new(key)
-            end
-          end
-        end
-
-        def strict(type_map)
-          schema(type_map, :strict_constructor)
-        end
-
-        def symbolized(type_map)
-          schema(type_map, :symbolized_constructor)
-        end
-
-        def schema(type_map, meth = :safe_constructor)
-          types = type_map.each_with_object({}) { |(name, type), result|
-            result[name] =
-              case type
-              when String, Class then Types[type]
-              else type
-              end
-          }
-
-          fn = self.class.method(meth).to_proc.curry.(types)
-
-          constructor(fn, schema: types)
-        end
-      end
-    end
-  end
-end