dry-types 0.15.0 → 1.0.0

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 @@
+# 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,9 +1,18 @@
+# frozen_string_literal: true
+
 require 'dry/types/fn_container'
+require 'dry/types/constructor/function'
 
 module Dry
   module Types
+    # 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, :meta, inspect: false)
+      include Dry::Equalizer(:type, :options, inspect: false)
+
+      private :meta
 
       # @return [#call]
       attr_reader :fn
@@ -16,124 +25,161 @@ module Dry
       # @param [Builder, Object] input
       # @param [Hash] options
       # @param [#call, nil] block
+      #
+      # @api public
       def self.new(input, **options, &block)
         type = input.is_a?(Builder) ? input : Nominal.new(input)
-        super(type, **options, &block)
+        super(type, **options, fn: Function[options.fetch(:fn, block)])
       end
 
+      # Instantiate a new constructor type instance
+      #
       # @param [Type] type
+      # @param [Function] fn
       # @param [Hash] options
-      # @param [#call, nil] block
-      def initialize(type, **options, &block)
+      #
+      # @api private
+      def initialize(type, fn: nil, **options)
         @type = type
-        @fn = options.fetch(:fn, block)
-
-        raise ArgumentError, 'Missing constructor block' if fn.nil?
+        @fn = fn
 
         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
 
-      # @param [Object] input
       # @return [Object]
-      def call(input)
-        type[fn[input]]
+      #
+      # @api private
+      def call_safe(input)
+        coerced = fn.(input) { return yield }
+        type.call_safe(coerced) { |output = coerced| yield(output) }
+      end
+
+      # @return [Object]
+      #
+      # @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 => error
+        failure = failure(input, error)
+        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, fn: -> input { left[right[input]] })
+        with({**options, fn: fn >> (new_fn || block)})
       end
       alias_method :append, :constructor
       alias_method :>>, :constructor
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        constructed_value = fn[value]
-      rescue NoMethodError, TypeError, ArgumentError
-        false
-      else
-        type.valid?(constructed_value)
-      end
-      alias_method :===, :valid?
-
       # @return [Class]
+      #
+      # @api private
       def constrained_type
         Constrained::Coercible
       end
 
-      # @api public
-      #
       # @see Nominal#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
 
-      # @api public
+      # 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)
-        left = new_fn || block
-        right = fn
-
-        with(**options, fn: -> input { right[left[input]] })
+        with({**options, fn: fn << (new_fn || block)})
       end
       alias_method :<<, :prepend
 
-      private
+      # Build a lax type
+      #
+      # @return [Lax]
+      # @api public
+      def lax
+        Lax.new(Constructor.new(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] method
       # @param [Array] args
       # @param [#call, nil] block
+      #
+      # @api private
       def method_missing(method, *args, &block)
         if type.respond_to?(method)
           response = type.__send__(method, *args, &block)
@@ -148,8 +194,9 @@ module Dry
         end
       end
 
+      # @api private
       def composable?(value)
-        value.kind_of?(Builder)
+        value.is_a?(Builder)
       end
     end
   end

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

@@ -0,0 +1,201 @@
+
+# frozen_string_literal: true
+
+require 'concurrent/map'
+
+module Dry
+  module Types
+    class Constructor < Nominal
+      # Function is used internally by Constructor types
+      #
+      # @api private
+      class Function
+        # Wrapper for unsafe coercion functions
+        #
+        # @api private
+        class Safe < Function
+          def call(input, &block)
+            @fn.(input, &block)
+          rescue NoMethodError, TypeError, ArgumentError => error
+            CoercionError.handle(error, &block)
+          end
+        end
+
+        # Coercion via a method call on a known object
+        #
+        # @api private
+        class MethodCall < Function
+          @cache = ::Concurrent::Map.new
+
+          # Choose or build the base class
+          #
+          # @return [Function]
+          def self.call_class(method, public, safe)
+            @cache.fetch_or_store([method, public, safe].hash) do
+              if public
+                ::Class.new(PublicCall) do
+                  include PublicCall.call_interface(method, safe)
+                end
+              elsif safe
+                PrivateCall
+              else
+                PrivateSafeCall
+              end
+            end
+          end
+
+          # Coercion with a publicly accessible method call
+          #
+          # @api private
+          class PublicCall < MethodCall
+            @interfaces = ::Concurrent::Map.new
+
+            # Choose or build the interface
+            #
+            # @return [::Module]
+            def self.call_interface(method, safe)
+              @interfaces.fetch_or_store([method, safe].hash) do
+                ::Module.new do
+                  if safe
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &block)
+                        @target.#{method}(input, &block)
+                      end
+                    RUBY
+                  else
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &block)
+                        @target.#{method}(input)
+                      rescue NoMethodError, TypeError, ArgumentError => error
+                        CoercionError.handle(error, &block)
+                      end
+                    RUBY
+                  end
+                end
+              end
+            end
+          end
+
+          # Coercion via a private method call
+          #
+          # @api private
+          class PrivateCall < MethodCall
+            def call(input, &block)
+              @target.send(@name, input, &block)
+            end
+          end
+
+          # Coercion via an unsafe private method call
+          #
+          # @api private
+          class PrivateSafeCall < PrivateCall
+            def call(input, &block)
+              @target.send(@name, input)
+            rescue NoMethodError, TypeError, ArgumentError => error
+              CoercionError.handle(error, &block)
+            end
+          end
+
+          # @api private
+          #
+          # @return [MethodCall]
+          def self.[](fn, safe)
+            public = fn.receiver.respond_to?(fn.name)
+            MethodCall.call_class(fn.name, public, safe).new(fn)
+          end
+
+          attr_reader :target, :name
+
+          def initialize(fn)
+            super
+            @target = fn.receiver
+            @name = fn.name
+          end
+
+          def to_ast
+            [:method, target, name]
+          end
+        end
+
+        # Choose or build specialized invokation code for a callable
+        #
+        # @param [#call] fn
+        # @return [Function]
+        def self.[](fn)
+          raise ArgumentError, 'Missing constructor block' if fn.nil?
+
+          if fn.is_a?(Function)
+            fn
+          elsif fn.is_a?(::Method)
+            MethodCall[fn, yields_block?(fn)]
+          elsif yields_block?(fn)
+            new(fn)
+          else
+            Safe.new(fn)
+          end
+        end
+
+        # @return [Boolean]
+        def self.yields_block?(fn)
+          *, (last_arg,) =
+            if fn.respond_to?(:parameters)
+              fn.parameters
+            else
+              fn.method(:call).parameters
+            end
+
+          last_arg.equal?(:block)
+        end
+
+        include Dry::Equalizer(:fn)
+
+        attr_reader :fn
+
+        def initialize(fn)
+          @fn = fn
+        end
+
+        # @return [Object]
+        def call(input, &block)
+          @fn.(input, &block)
+        end
+        alias_method :[], :call
+
+        # @return [Array]
+        def to_ast
+          if fn.is_a?(::Proc)
+            [:id, Dry::Types::FnContainer.register(fn)]
+          else
+            [:callable, fn]
+          end
+        end
+
+        if RUBY_VERSION >= '2.6'
+          # @return [Function]
+          def >>(other)
+            proc = other.is_a?(::Proc) ? other : other.fn
+            Function[@fn >> proc]
+          end
+
+          # @return [Function]
+          def <<(other)
+            proc = other.is_a?(::Proc) ? other : other.fn
+            Function[@fn << proc]
+          end
+        else
+          # @return [Function]
+          def >>(other)
+            proc = other.is_a?(::Proc) ? other : other.fn
+            Function[-> x { proc[@fn[x]] }]
+          end
+
+          # @return [Function]
+          def <<(other)
+            proc = other.is_a?(::Proc) ? other : other.fn
+            Function[-> x { @fn[proc[x]] }]
+          end
+        end
+      end
+    end
+  end
+end