dry-types 0.15.0 → 1.2.0

data/lib/dry/types/array.rb

@@ -1,10 +1,21 @@
+# frozen_string_literal: true
+
 require 'dry/types/array/member'
+require 'dry/types/array/constructor'
 
 module Dry
   module Types
+    # Array type can be used to define an array with optional member type
+    #
+    # @api public
     class Array < Nominal
-      # @param [Type] type
+      # Build an array type with a member type
+      #
+      # @param [Type,#call] type
+      #
       # @return [Array::Member]
+      #
+      # @api public
       def of(type)
         member =
           case type
@@ -14,6 +25,11 @@ module Dry
 
         Array::Member.new(primitive, **options, member: member)
       end
+
+      # @api private
+      def constructor_type
+        ::Dry::Types::Array::Constructor
+      end
     end
   end
 end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'dry/types/constructor'
+
+module Dry
+  module Types
+    # @api public
+    class Array < Nominal
+      # @api private
+      class Constructor < ::Dry::Types::Constructor
+        # @api private
+        def constructor_type
+          ::Dry::Types::Array::Constructor
+        end
+
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          Lax.new(type.lax.constructor(fn, meta: meta))
+        end
+
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def of(member)
+          type.of(member).constructor(fn, meta: meta)
+        end
+      end
+    end
+  end
+end

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

@@ -1,46 +1,91 @@
+# frozen_string_literal: true
+
+require 'dry/types/array/constructor'
+
 module Dry
   module Types
     class Array < Nominal
+      # Member arrays define their member type that is applied to each element
+      #
+      # @api public
       class Member < Array
         # @return [Type]
         attr_reader :member
 
         # @param [Class] primitive
         # @param [Hash] options
+        #
         # @option options [Type] :member
+        #
+        # @api private
         def initialize(primitive, options = {})
           @member = options.fetch(:member)
           super
         end
 
         # @param [Object] input
-        # @param [Symbol] meth
+        #
         # @return [Array]
-        def call(input, meth = :call)
-          input.map { |el| member.__send__(meth, el) }
+        #
+        # @api private
+        def call_unsafe(input)
+          if primitive?(input)
+            input.each_with_object([]) do |el, output|
+              coerced = member.call_unsafe(el)
+
+              output << coerced unless Undefined.equal?(coerced)
+            end
+          else
+            super
+          end
         end
-        alias_method :[], :call
 
-        # @param [Array, #all?, Object] value
-        # @return [Boolean]
-        def valid?(value)
-          super && value.all? { |el| member.valid?(el) }
+        # @param [Object] input
+        # @return [Array]
+        #
+        # @api private
+        def call_safe(input)
+          if primitive?(input)
+            failed = false
+
+            result = input.each_with_object([]) do |el, output|
+              coerced = member.call_safe(el) { |out = el|
+                failed = true
+                out
+              }
+
+              output << coerced unless Undefined.equal?(coerced)
+            end
+
+            failed ? yield(result) : result
+          else
+            yield
+          end
         end
 
         # @param [Array, Object] input
         # @param [#call,nil] block
+        #
         # @yieldparam [Failure] failure
         # @yieldreturn [Result]
+        #
         # @return [Result,Logic::Result]
+        #
+        # @api public
         def try(input, &block)
-          if input.is_a?(::Array)
-            result = call(input, :try).reject { |r| r.input.equal?(Undefined) }
-            output = result.map(&:input)
+          if primitive?(input)
+            output = []
+
+            result = input.map { |el| member.try(el) }
+            result.each do |r|
+              output << r.input unless Undefined.equal?(r.input)
+            end
 
             if result.all?(&:success?)
               success(output)
             else
-              failure = failure(output, result.select(&:failure?))
+              error = result.find(&:failure?).error
+              failure = failure(output, error)
               block ? yield(failure) : failure
             end
           else
@@ -49,9 +94,18 @@ module Dry
           end
         end
 
-        # @api public
+        # Build a lax type
         #
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          Lax.new(Member.new(primitive, { **options, member: member.lax, meta: meta }))
+        end
+
         # @see Nominal#to_ast
+        #
+        # @api public
         def to_ast(meta: true)
           if member.respond_to?(:to_ast)
             [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
@@ -59,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

@@ -1,43 +1,72 @@
+# frozen_string_literal: true
+
 require 'dry/core/deprecations'
 
 module Dry
   module Types
+    # Common API for building types and composition
+    #
+    # @api public
     module Builder
       include Dry::Core::Constants
 
       # @return [Class]
+      #
+      # @api private
       def constrained_type
         Constrained
       end
 
       # @return [Class]
+      #
+      # @api private
       def constructor_type
         Constructor
       end
 
+      # Compose two types into a Sum type
+      #
       # @param [Type] other
+      #
       # @return [Sum, Sum::Constrained]
+      #
+      # @api private
       def |(other)
         klass = constrained? && other.constrained? ? Sum::Constrained : Sum
         klass.new(self, other)
       end
 
+      # Turn a type into an optional type
+      #
       # @return [Sum]
+      #
+      # @api public
       def optional
         Types['strict.nil'] | self
       end
 
+      # Turn a type into a constrained type
+      #
       # @param [Hash] options constraining rule (see {Types.Rule})
+      #
       # @return [Constrained]
+      #
+      # @api public
       def constrained(options)
         constrained_type.new(self, rule: Types.Rule(options))
       end
 
+      # Turn a type into a type with a default value
+      #
       # @param [Object] input
       # @param [Hash] options
       # @param [#call,nil] block
+      #
       # @raise [ConstraintError]
+      #
       # @return [Default]
+      #
+      # @api public
       def default(input = Undefined, options = EMPTY_HASH, &block)
         unless input.frozen? || options[:shared]
           where = Dry::Core::Deprecations::STACK.()
@@ -46,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
@@ -60,8 +89,13 @@ module Dry
         end
       end
 
+      # Define an enum on top of the existing type
+      #
       # @param [Array] values
+      #
       # @return [Enum]
+      #
+      # @api public
       def enum(*values)
         mapping =
           if values.length == 1 && values[0].is_a?(::Hash)
@@ -73,15 +107,25 @@ module Dry
         Enum.new(constrained(included_in: mapping.keys), mapping: mapping)
       end
 
-      # @return [Safe]
-      def safe
-        Safe.new(self)
+      # Turn a type into a lax type that will rescue from type-errors and
+      # return the original input
+      #
+      # @return [Lax]
+      #
+      # @api public
+      def lax
+        Lax.new(self)
       end
 
+      # Define a constructor for the type
+      #
       # @param [#call,nil] constructor
       # @param [Hash] options
       # @param [#call,nil] block
+      #
       # @return [Constructor]
+      #
+      # @api public
       def constructor(constructor = nil, **options, &block)
         constructor_type.new(with(options), fn: constructor || block)
       end
@@ -92,5 +136,5 @@ end
 require 'dry/types/default'
 require 'dry/types/constrained'
 require 'dry/types/enum'
-require 'dry/types/safe'
+require 'dry/types/lax'
 require 'dry/types/sum'

data/lib/dry/types/builder_methods.rb

@@ -1,5 +1,12 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for building type objects in a convenient way
+    #
+    # rubocop:disable Naming/MethodName
+    #
+    # @api public
     module BuilderMethods
       # @api private
       def included(base)
@@ -8,7 +15,8 @@ module Dry
       end
 
       # Build an array type.
-      # It is a shortcut for Array.of
+      #
+      # Shortcut for Array#of.
       #
       # @example
       #   Types::Strings = Types.Array(Types::String)
@@ -17,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
@@ -25,9 +33,8 @@ module Dry
       # @param [Hash{Symbol => Dry::Types::Type}] type_map
       #
       # @return [Dry::Types::Array]
-      # @api public
       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
@@ -41,9 +48,8 @@ module Dry
       # @param [Class,Module] klass Class or module
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Instance(klass)
-        Nominal.new(klass).constrained(type: klass)
+        Nominal(klass).constrained(type: klass)
       end
       alias_method :Strict, :Instance
 
@@ -53,9 +59,8 @@ module Dry
       # @param [Object] value
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Value(value)
-        Nominal.new(value.class).constrained(eql: value)
+        Nominal(value.class).constrained(eql: value)
       end
 
       # Build a type with a single value
@@ -64,9 +69,8 @@ module Dry
       # @param [Object] object
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Constant(object)
-        Nominal.new(object.class).constrained(is: object)
+        Nominal(object.class).constrained(is: object)
       end
 
       # Build a constructor type
@@ -77,9 +81,12 @@ module Dry
       # @param [#call,nil] block Value constructor
       #
       # @return [Dry::Types::Type]
-      # @api public
       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
@@ -87,9 +94,14 @@ module Dry
       # @param [Class] klass
       #
       # @return [Dry::Types::Type]
-      # @api public
       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
@@ -102,9 +114,24 @@ module Dry
       # @param [Type] value_type Value type
       #
       # @return [Dry::Types::Map]
-      # @api public
       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.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