dry-types 1.0.1 → 1.2.0

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dry/types/array/constructor'
+
 module Dry
   module Types
     class Array < Nominal
@@ -98,7 +100,7 @@ module Dry
         #
         # @api public
         def lax
-          Lax.new(Member.new(primitive, { **options, member: member.lax }))
+          Lax.new(Member.new(primitive, { **options, member: member.lax, meta: meta }))
         end
 
         # @see Nominal#to_ast
@@ -111,6 +113,11 @@ module Dry
             [:array, [member, meta ? self.meta : EMPTY_HASH]]
           end
         end
+
+        # @api private
+        def constructor_type
+          ::Dry::Types::Array::Constructor
+        end
       end
     end
   end

data/lib/dry/types/builder.rb

@@ -75,7 +75,7 @@ module Dry
             ' Be careful: types will return the same instance of the default'\
             ' value every time. Call `.freeze` when setting the default'\
             ' or pass `shared: true` to discard this warning.'\
-            "\n#{ where }",
+            "\n#{where}",
             tag: :'dry-types'
           )
         end

data/lib/dry/types/builder_methods.rb

@@ -25,7 +25,7 @@ module Dry
       #
       # @return [Dry::Types::Array]
       def Array(type)
-        self::Array.of(type)
+        Strict(::Array).of(type)
       end
 
       # Build a hash schema
@@ -34,7 +34,7 @@ module Dry
       #
       # @return [Dry::Types::Array]
       def Hash(type_map)
-        self::Hash.schema(type_map)
+        Strict(::Hash).schema(type_map)
       end
 
       # Build a type which values are instances of a given class
@@ -49,7 +49,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Instance(klass)
-        Nominal.new(klass).constrained(type: klass)
+        Nominal(klass).constrained(type: klass)
       end
       alias_method :Strict, :Instance
 
@@ -60,7 +60,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Value(value)
-        Nominal.new(value.class).constrained(eql: value)
+        Nominal(value.class).constrained(eql: value)
       end
 
       # Build a type with a single value
@@ -70,7 +70,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Constant(object)
-        Nominal.new(object.class).constrained(is: object)
+        Nominal(object.class).constrained(is: object)
       end
 
       # Build a constructor type
@@ -82,7 +82,11 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Constructor(klass, cons = nil, &block)
-        Nominal.new(klass).constructor(cons || block || klass.method(:new))
+        if klass.is_a?(Type)
+          klass.constructor(cons || block || klass.method(:new))
+        else
+          Nominal(klass).constructor(cons || block || klass.method(:new))
+        end
       end
 
       # Build a nominal type
@@ -91,7 +95,13 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Nominal(klass)
-        Nominal.new(klass)
+        if klass <= ::Array
+          Array.new(klass)
+        elsif klass <= ::Hash
+          Hash.new(klass)
+        else
+          Nominal.new(klass)
+        end
       end
 
       # Build a map type
@@ -105,24 +115,24 @@ module Dry
       #
       # @return [Dry::Types::Map]
       def Map(key_type, value_type)
-        Types['nominal.hash'].map(key_type, value_type)
+        Nominal(::Hash).map(key_type, value_type)
       end
 
-      # # Builds a constrained nominal type accepting any value that
-      # # responds to given methods
-      # #
-      # # @example
-      # #   Types::Callable = Types.Contract(:call)
-      # #   Types::Contact = Types.Contract(:name, :address)
-      # #
-      # # @param methods [Array<String, Symbol>] Method names
-      # #
-      # # @return [Dry::Types::Contrained]
-      # def Contract(*methods)
-      #   methods.reduce(Types['nominal.any']) do |type, method|
-      #     type.constrained(respond_to: method)
-      #   end
-      # end
+      # Builds a constrained nominal type accepting any value that
+      # responds to given methods
+      #
+      # @example
+      #   Types::Callable = Types.Interface(:call)
+      #   Types::Contact = Types.Interface(:name, :address)
+      #
+      # @param methods [Array<String, Symbol>] Method names
+      #
+      # @return [Dry::Types::Contrained]
+      def Interface(*methods)
+        methods.reduce(Types['nominal.any']) do |type, method|
+          type.constrained(respond_to: method)
+        end
+      end
     end
   end
 end

data/lib/dry/types/coercions.rb

@@ -36,8 +36,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Date.parse(input)
-          rescue ArgumentError, RangeError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError, RangeError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -57,8 +57,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::DateTime.parse(input)
-          rescue ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -78,8 +78,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Time.parse(input)
-          rescue ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -88,6 +88,19 @@ module Dry
         end
       end
 
+      # @param [#to_sym, Object] input
+      #
+      # @return [Symbol, Object]
+      #
+      # @raise CoercionError
+      #
+      # @api public
+      def to_symbol(input, &block)
+        input.to_sym
+      rescue NoMethodError => e
+        CoercionError.handle(e, &block)
+      end
+
       private
 
       # Checks whether String is empty

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

@@ -71,8 +71,8 @@ module Dry
           else
             Integer(input)
           end
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_f, Object] input
@@ -84,8 +84,8 @@ module Dry
         # @api public
         def self.to_float(input, &block)
           Float(input)
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_d, Object] input

data/lib/dry/types/constrained.rb

@@ -126,6 +126,11 @@ module Dry
         [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
       end
 
+      # @api private
+      def constructor_type
+        type.constructor_type
+      end
+
       private
 
       # @param [Object] response

data/lib/dry/types/constructor.rb

@@ -12,15 +12,13 @@ module Dry
     class Constructor < Nominal
       include Dry::Equalizer(:type, :options, inspect: false)
 
-      private :meta
-
       # @return [#call]
       attr_reader :fn
 
       # @return [Type]
       attr_reader :type
 
-      undef :constrained?
+      undef :constrained?, :meta, :optional?, :primitive, :default?, :name
 
       # @param [Builder, Object] input
       # @param [Hash] options
@@ -46,31 +44,6 @@ module Dry
         super(type, **options, fn: fn)
       end
 
-      # Return the inner type's primitive
-      #
-      # @return [Class]
-      #
-      # @api public
-      def primitive
-        type.primitive
-      end
-
-      # Return the inner type's name
-      #
-      # @return [String]
-      #
-      # @api public
-      def name
-        type.name
-      end
-
-      # @return [Boolean]
-      #
-      # @api public
-      def default?
-        type.default?
-      end
-
       # @return [Object]
       #
       # @api private
@@ -95,8 +68,8 @@ module Dry
       # @api public
       def try(input, &block)
         value = fn.(input)
-      rescue CoercionError => error
-        failure = failure(input, error)
+      rescue CoercionError => e
+        failure = failure(input, e)
         block_given? ? yield(failure) : failure
       else
         type.try(value, &block)
@@ -182,9 +155,9 @@ module Dry
       # @api private
       def method_missing(method, *args, &block)
         if type.respond_to?(method)
-          response = type.__send__(method, *args, &block)
+          response = type.public_send(method, *args, &block)
 
-          if composable?(response)
+          if response.is_a?(Type) && type.class == response.class
             response.constructor_type.new(response, options)
           else
             response
@@ -193,11 +166,6 @@ module Dry
           super
         end
       end
-
-      # @api private
-      def composable?(value)
-        value.is_a?(Builder)
-      end
     end
   end
 end

data/lib/dry/types/constructor/function.rb

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require 'concurrent/map'
@@ -16,8 +15,8 @@ module Dry
         class Safe < Function
           def call(input, &block)
             @fn.(input, &block)
-          rescue NoMethodError, TypeError, ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue NoMethodError, TypeError, ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         end
 
@@ -91,8 +90,8 @@ module Dry
           class PrivateSafeCall < PrivateCall
             def call(input, &block)
               @target.send(@name, input)
-            rescue NoMethodError, TypeError, ArgumentError => error
-              CoercionError.handle(error, &block)
+            rescue NoMethodError, TypeError, ArgumentError => e
+              CoercionError.handle(e, &block)
             end
           end
 

data/lib/dry/types/core.rb

@@ -5,7 +5,7 @@ require 'dry/types/any'
 module Dry
   module Types
     # Primitives with {Kernel} coercion methods
-    COERCIBLE = {
+    KERNEL_COERCIBLE = {
       string: String,
       integer: Integer,
       float: Float,
@@ -14,10 +14,19 @@ module Dry
       hash: ::Hash
     }.freeze
 
-    # Primitives that are non-coercible through {Kernel} methods
+    # Primitives with coercions through by convention `to_*` methods
+    METHOD_COERCIBLE = {
+      symbol: Symbol
+    }.freeze
+
+    # By convention methods to coerce {METHOD_COERCIBLE} primitives
+    METHOD_COERCIBLE_METHODS = {
+      symbol: :to_sym
+    }.freeze
+
+    # Primitives that are non-coercible
     NON_COERCIBLE = {
       nil: NilClass,
-      symbol: Symbol,
       class: Class,
       true: TrueClass,
       false: FalseClass,
@@ -28,7 +37,10 @@ module Dry
     }.freeze
 
     # All built-in primitives
-    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
+    ALL_PRIMITIVES = [KERNEL_COERCIBLE, METHOD_COERCIBLE, NON_COERCIBLE].reduce(&:merge).freeze
+
+    # All coercible types
+    COERCIBLE = KERNEL_COERCIBLE.merge(METHOD_COERCIBLE).freeze
 
     # All built-in primitives except {NilClass}
     NON_NIL = ALL_PRIMITIVES.reject { |name, _| name == :nil }.freeze
@@ -46,11 +58,18 @@ module Dry
       register("strict.#{name}", type)
     end
 
-    # Register {COERCIBLE} types
-    COERCIBLE.each do |name, primitive|
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
       register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
+    # Register {METHOD_COERCIBLE} types
+    METHOD_COERCIBLE.each_key do |name|
+      register(
+        "coercible.#{name}", self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+      )
+    end
+
     # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
       register("optional.strict.#{name}", self["strict.#{name}"].optional)
@@ -64,8 +83,8 @@ module Dry
     # Register `:bool` since it's common and not a built-in Ruby type :(
     register('nominal.bool', self['nominal.true'] | self['nominal.false'])
     bool = self['strict.true'] | self['strict.false']
-    register("strict.bool", bool)
-    register("bool", bool)
+    register('strict.bool', bool)
+    register('bool', bool)
 
     register('any', Any)
     register('nominal.any', Any)

data/lib/dry/types/decorator.rb

@@ -90,7 +90,7 @@ module Dry
       # @api private
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+          response = type.public_send(meth, *args, &block)
 
           if decorate?(response)
             __new__(response)

data/lib/dry/types/enum.rb

@@ -11,6 +11,7 @@ module Dry
       include Type
       include Dry::Equalizer(:type, :mapping, inspect: false)
       include Decorator
+      include Builder
 
       # @return [Array]
       attr_reader :values

data/lib/dry/types/extensions.rb

@@ -3,3 +3,7 @@
 Dry::Types.register_extension(:maybe) do
   require 'dry/types/extensions/maybe'
 end
+
+Dry::Types.register_extension(:monads) do
+  require 'dry/types/extensions/monads'
+end