dry-types 0.13.2 → 1.5.1

data/lib/dry/types/compat.rb

@@ -1,2 +0,0 @@
-require 'dry/types/compat/int'
-require 'dry/types/compat/form_types'

data/lib/dry/types/compiler.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+
 module Dry
   module Types
+    # @api private
     class Compiler
+      extend ::Dry::Core::Deprecations[:'dry-types']
+
       attr_reader :registry
 
       def initialize(registry)
@@ -13,33 +20,34 @@ module Dry
 
       def visit(node)
         type, body = node
-        send(:"visit_#{ type }", body)
+        send(:"visit_#{type}", body)
       end
 
       def visit_constrained(node)
-        definition, rule, meta = node
-        Types::Constrained.new(visit(definition), rule: visit_rule(rule)).meta(meta)
+        nominal, rule = node
+        type = visit(nominal)
+        type.constrained_type.new(type, rule: visit_rule(rule))
       end
 
       def visit_constructor(node)
-        definition, fn_register_name, meta = node
-        fn = Dry::Types::FnContainer[fn_register_name]
-        primitive = visit(definition)
-        Types::Constructor.new(primitive, meta: meta, fn: fn)
+        nominal, fn = node
+        primitive = visit(nominal)
+        primitive.constructor(compile_fn(fn))
       end
 
-      def visit_safe(node)
-        ast, meta = node
-        Types::Safe.new(visit(ast), meta: meta)
+      def visit_lax(node)
+        Types::Lax.new(visit(node))
       end
+      deprecate(:visit_safe, :visit_lax)
 
-      def visit_definition(node)
+      def visit_nominal(node)
         type, meta = node
+        nominal_name = "nominal.#{Types.identifier(type)}"
 
-        if registry.registered?(type)
-          registry[type].meta(meta)
+        if registry.registered?(nominal_name)
+          registry[nominal_name].meta(meta)
         else
-          Definition.new(type, meta: meta)
+          Nominal.new(type, meta: meta)
         end
       end
 
@@ -55,65 +63,72 @@ module Dry
       def visit_array(node)
         member, meta = node
         member = member.is_a?(Class) ? member : visit(member)
-        registry['array'].of(member).meta(meta)
+        registry["nominal.array"].of(member).meta(meta)
       end
 
       def visit_hash(node)
-        constructor, schema, meta = node
-        merge_with('hash', constructor, schema).meta(meta)
+        opts, meta = node
+        registry["nominal.hash"].with(**opts, meta: meta)
       end
 
-      def visit_hash_schema(node)
-        schema, meta = node
-        merge_with_schema('hash', schema).meta(meta)
+      def visit_schema(node)
+        keys, options, meta = node
+        registry["nominal.hash"].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
       end
 
       def visit_json_hash(node)
-        schema, meta = node
-        merge_with('json.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry["json.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_json_array(node)
         member, meta = node
-        registry['json.array'].of(visit(member)).meta(meta)
+        registry["json.array"].of(visit(member)).meta(meta)
       end
 
       def visit_params_hash(node)
-        schema, meta = node
-        merge_with('params.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry["params.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_params_array(node)
         member, meta = node
-        registry['params.array'].of(visit(member)).meta(meta)
+        registry["params.array"].of(visit(member)).meta(meta)
       end
 
-      def visit_member(node)
-        name, type = node
-        { name => visit(type) }
+      def visit_key(node)
+        name, required, type = node
+        Schema::Key.new(visit(type), name, required: required)
       end
 
       def visit_enum(node)
-        type, mapping, meta = node
-        Enum.new(visit(type), mapping: mapping, meta: meta)
+        type, mapping = node
+        Enum.new(visit(type), mapping: mapping)
       end
 
       def visit_map(node)
         key_type, value_type, meta = node
-        registry['hash'].map(visit(key_type), visit(value_type)).meta(meta)
+        registry["nominal.hash"].map(visit(key_type), visit(value_type)).meta(meta)
       end
 
-      def merge_with(hash_id, constructor, schema)
-        registry[hash_id].schema(
-          schema.map { |key| visit(key) }.reduce({}, :update),
-          constructor
-        )
+      def visit_any(meta)
+        registry["any"].meta(meta)
       end
 
-      def merge_with_schema(hash_id, schema)
-        registry[hash_id].instantiate(
-          schema.map { |key| visit(key) }.reduce({}, :update)
-        )
+      def compile_fn(fn)
+        type, *node = fn
+
+        case type
+        when :id
+          Dry::Types::FnContainer[node.fetch(0)]
+        when :callable
+          node.fetch(0)
+        when :method
+          target, method = node
+          target.method(method)
+        else
+          raise ArgumentError, "Cannot build callable from #{fn.inspect}"
+        end
       end
     end
   end

data/lib/dry/types/constrained.rb

@@ -1,93 +1,142 @@
-require 'dry/types/decorator'
-require 'dry/types/constraints'
-require 'dry/types/constrained/coercible'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/decorator"
+require "dry/types/constraints"
+require "dry/types/constrained/coercible"
 
 module Dry
   module Types
+    # Constrained types apply rules to the input
+    #
+    # @api public
     class Constrained
       include Type
-      include Dry::Equalizer(:type, :options, :rule, :meta)
       include Decorator
       include Builder
+      include Printable
+      include Dry::Equalizer(:type, :rule, inspect: false, immutable: true)
 
       # @return [Dry::Logic::Rule]
       attr_reader :rule
 
       # @param [Type] type
+      #
       # @param [Hash] options
-      def initialize(type, options)
+      #
+      # @api public
+      def initialize(type, **options)
         super
         @rule = options.fetch(:rule)
       end
 
-      # @param [Object] input
       # @return [Object]
-      # @raise [ConstraintError]
-      def call(input)
-        try(input) do |result|
+      #
+      # @api private
+      def call_unsafe(input)
+        result = rule.(input)
+
+        if result.success?
+          type.call_unsafe(input)
+        else
           raise ConstraintError.new(result, input)
-        end.input
+        end
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        if rule[input]
+          type.call_safe(input, &block)
+        else
+          yield
+        end
       end
-      alias_method :[], :call
-
-      # @param [Object] input
-      # @param [#call,nil] block
-      # @yieldparam [Failure] failure
-      # @yieldreturn [Result]
-      # @return [Logic::Result, Result]
-      # @return [Object] if block given and try fails
+
+      # Safe coercion attempt. It is similar to #call with a
+      # block given but returns a Result instance with metadata
+      # about errors (if any).
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @return [Logic::Result]
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @yieldparam [Failure] failure
+      #   @yieldreturn [Object]
+      #   @return [Object]
+      #
+      # @api public
       def try(input, &block)
         result = rule.(input)
 
         if result.success?
           type.try(input, &block)
         else
-          failure = failure(input, result)
-          block ? yield(failure) : failure
+          failure = failure(input, ConstraintError.new(result, input))
+          block_given? ? yield(failure) : failure
         end
       end
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        rule.(value).success? && type.valid?(value)
-      end
-
       # @param [Hash] options
       #   The options hash provided to {Types.Rule} and combined
       #   using {&} with previous {#rule}
+      #
       # @return [Constrained]
+      #
       # @see Dry::Logic::Operators#and
+      #
+      # @api public
       def constrained(options)
         with(rule: rule & Types.Rule(options))
       end
 
       # @return [true]
+      #
+      # @api public
       def constrained?
         true
       end
 
       # @param [Object] value
+      #
       # @return [Boolean]
+      #
+      # @api public
       def ===(value)
         valid?(value)
       end
 
-      # @api public
+      # Build lax type. Constraints are not applicable to lax types hence unwrapping
       #
-      # @see Definition#to_ast
+      # @return [Lax]
+      # @api public
+      def lax
+        type.lax
+      end
+
+      # @see Nominal#to_ast
+      # @api public
       def to_ast(meta: true)
-        [:constrained, [type.to_ast(meta: meta),
-                        rule.to_ast,
-                        meta ? self.meta : EMPTY_HASH]]
+        [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
+      end
+
+      # @api private
+      def constructor_type
+        type.constructor_type
       end
 
       private
 
       # @param [Object] response
+      #
       # @return [Boolean]
+      #
+      # @api private
       def decorate?(response)
-        super || response.kind_of?(Constructor)
+        super || response.is_a?(Constructor)
       end
     end
   end

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

@@ -1,12 +1,42 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
     class Constrained
+      # Common coercion-related API for constrained types
+      #
+      # @api public
       class Coercible < Constrained
-        # @param [Object] input
-        # @param [#call,nil] block
-        # @yieldparam [Failure] failure
-        # @yieldreturn [Result]
-        # @return [Result,nil]
+        # @return [Object]
+        #
+        # @api private
+        def call_unsafe(input)
+          coerced = type.call_unsafe(input)
+          result = rule.(coerced)
+
+          if result.success?
+            coerced
+          else
+            raise ConstraintError.new(result, input)
+          end
+        end
+
+        # @return [Object]
+        #
+        # @api private
+        def call_safe(input)
+          coerced = type.call_safe(input) { return yield }
+
+          if rule[coerced]
+            coerced
+          else
+            yield(coerced)
+          end
+        end
+
+        # @see Dry::Types::Constrained#try
+        #
+        # @api public
         def try(input, &block)
           result = type.try(input)
 
@@ -16,7 +46,7 @@ module Dry
             if validation.success?
               result
             else
-              failure = failure(result.input, validation)
+              failure = failure(result.input, ConstraintError.new(validation, input))
               block ? yield(failure) : failure
             end
           else

data/lib/dry/types/constraints.rb

@@ -1,18 +1,32 @@
-require 'dry/logic/rule_compiler'
-require 'dry/logic/predicates'
-require 'dry/logic/rule/predicate'
+# frozen_string_literal: true
+
+require "dry/logic/rule_compiler"
+require "dry/logic/predicates"
+require "dry/logic/rule/predicate"
 
 module Dry
+  # Helper methods for constraint types
+  #
+  # @api public
   module Types
     # @param [Hash] options
+    #
     # @return [Dry::Logic::Rule]
+    #
+    # @api public
     def self.Rule(options)
       rule_compiler.(
-        options.map { |key, val| Logic::Rule::Predicate.new(Logic::Predicates[:"#{key}?"]).curry(val).to_ast }
+        options.map { |key, val|
+          Logic::Rule::Predicate.build(
+            Logic::Predicates[:"#{key}?"]
+          ).curry(val).to_ast
+        }
       ).reduce(:and)
     end
 
     # @return [Dry::Logic::RuleCompiler]
+    #
+    # @api private
     def self.rule_compiler
       @rule_compiler ||= Logic::RuleCompiler.new(Logic::Predicates)
     end

data/lib/dry/types/constructor.rb

@@ -1,10 +1,18 @@
-require 'dry/types/decorator'
-require 'dry/types/fn_container'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/fn_container"
+require "dry/types/constructor/function"
+require "dry/types/constructor/wrapper"
 
 module Dry
   module Types
-    class Constructor < Definition
-      include Dry::Equalizer(:type, :options, :meta)
+    # Constructor types apply a function to the input that is supposed to return
+    # a new value. Coercion is a common use case for constructor types.
+    #
+    # @api public
+    class Constructor < Nominal
+      include Dry::Equalizer(:type, :options, inspect: false, immutable: true)
 
       # @return [#call]
       attr_reader :fn
@@ -12,114 +20,179 @@ module Dry
       # @return [Type]
       attr_reader :type
 
-      undef :constrained?
+      undef :constrained?, :meta, :optional?, :primitive, :default?, :name
 
       # @param [Builder, Object] input
       # @param [Hash] options
       # @param [#call, nil] block
-      def self.new(input, options = {}, &block)
-        type = input.is_a?(Builder) ? input : Definition.new(input)
-        super(type, options, &block)
+      #
+      # @api public
+      def self.new(input, **options, &block)
+        type = input.is_a?(Builder) ? input : Nominal.new(input)
+        super(type, **options, fn: Function[options.fetch(:fn, block)])
       end
 
-      # @param [Type] type
+      # @param [Builder, Object] input
       # @param [Hash] options
       # @param [#call, nil] block
-      def initialize(type, options = {}, &block)
-        @type = type
-        @fn = options.fetch(:fn, block)
-
-        raise ArgumentError, 'Missing constructor block' if fn.nil?
+      #
+      # @api public
+      def self.[](type, fn:, **options)
+        function = Function[fn]
 
-        super(type, **options, fn: fn)
+        if function.wrapper?
+          wrapper_type.new(type, fn: function, **options)
+        else
+          new(type, fn: function, **options)
+        end
       end
 
-      # @return [Class]
-      def primitive
-        type.primitive
+      # @api private
+      def self.wrapper_type
+        @wrapper_type ||= begin
+          if self < Wrapper
+            self
+          else
+            const_set(:Wrapping, ::Class.new(self).include(Wrapper))
+          end
+        end
       end
 
-      # @return [String]
-      def name
-        type.name
+      # Instantiate a new constructor type instance
+      #
+      # @param [Type] type
+      # @param [Function] fn
+      # @param [Hash] options
+      #
+      # @api private
+      def initialize(type, fn: nil, **options)
+        @type = type
+        @fn = fn
+
+        super(type, **options, fn: fn)
       end
 
-      def default?
-        type.default?
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input)
+        coerced = fn.(input) { |output = input| return yield(output) }
+        type.call_safe(coerced) { |output = coerced| yield(output) }
       end
 
-      # @param [Object] input
       # @return [Object]
-      def call(input)
-        type[fn[input]]
+      #
+      # @api private
+      def call_unsafe(input)
+        type.call_unsafe(fn.(input))
       end
-      alias_method :[], :call
 
       # @param [Object] input
       # @param [#call,nil] block
+      #
       # @return [Logic::Result, Types::Result]
       # @return [Object] if block given and try fails
+      #
+      # @api public
       def try(input, &block)
-        type.try(fn[input], &block)
-      rescue TypeError, ArgumentError => e
-        failure(input, e.message)
+        value = fn.(input)
+      rescue CoercionError => e
+        failure = failure(input, e)
+        block_given? ? yield(failure) : failure
+      else
+        type.try(value, &block)
       end
 
+      # Build a new constructor by appending a block to the coercion function
+      #
       # @param [#call, nil] new_fn
       # @param [Hash] options
       # @param [#call, nil] block
+      #
       # @return [Constructor]
+      #
+      # @api public
       def constructor(new_fn = nil, **options, &block)
-        left = new_fn || block
-        right = fn
-
-        with(options.merge(fn: -> input { left[right[input]] }))
-      end
+        next_fn = Function[new_fn || block]
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        type.valid?(value)
+        if next_fn.wrapper?
+          self.class.wrapper_type.new(with(**options), fn: next_fn)
+        else
+          with(**options, fn: fn >> next_fn)
+        end
       end
-      alias_method :===, :valid?
+      alias_method :append, :constructor
+      alias_method :>>, :constructor
 
       # @return [Class]
+      #
+      # @api private
       def constrained_type
         Constrained::Coercible
       end
 
-      # @api public
+      # @see Nominal#to_ast
       #
-      # @see Definition#to_ast
+      # @api public
       def to_ast(meta: true)
-        [:constructor, [type.to_ast(meta: meta),
-                        register_fn(fn),
-                        meta ? self.meta : EMPTY_HASH]]
+        [:constructor, [type.to_ast(meta: meta), fn.to_ast]]
       end
 
-      private
+      # Build a new constructor by prepending a block to the coercion function
+      #
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @return [Constructor]
+      #
+      # @api public
+      def prepend(new_fn = nil, **options, &block)
+        with(**options, fn: fn << (new_fn || block))
+      end
+      alias_method :<<, :prepend
+
+      # Build a lax type
+      #
+      # @return [Lax]
+      # @api public
+      def lax
+        Lax.new(constructor_type[type.lax, **options])
+      end
 
-      def register_fn(fn)
-        Dry::Types::FnContainer.register(fn)
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        proc { |value| self.(value) }
       end
 
+      private
+
       # @param [Symbol] meth
       # @param [Boolean] include_private
       # @return [Boolean]
+      #
+      # @api private
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
       # Delegates missing methods to {#type}
-      # @param [Symbol] meth
+      #
+      # @param [Symbol] method
       # @param [Array] args
       # @param [#call, nil] block
-      def method_missing(meth, *args, &block)
-        if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+      #
+      # @api private
+      def method_missing(method, *args, &block)
+        if type.respond_to?(method)
+          response = type.public_send(method, *args, &block)
 
-          if response.kind_of?(Builder)
-            self.class.new(response, options)
+          if response.is_a?(Type) && type.class.equal?(response.class)
+            response.constructor_type[response, **options]
           else
             response
           end