dry-types 0.14.1 → 1.5.1

data/lib/dry/types/constructor.rb

@@ -1,9 +1,18 @@
-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
@@ -11,118 +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
+      #
+      # @api public
       def self.new(input, **options, &block)
-        type = input.is_a?(Builder) ? input : Definition.new(input)
-        super(type, **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)
-        constructed_value = fn[value]
-      rescue NoMethodError, TypeError, ArgumentError
-        false
-      else
-        type.valid?(constructed_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

data/lib/dry/types/container.rb

@@ -1,5 +1,12 @@
+# frozen_string_literal: true
+
+require "dry/container"
+
 module Dry
   module Types
+    # Internal container for the built-in types
+    #
+    # @api private
     class Container
       include Dry::Container::Mixin
     end

data/lib/dry/types/core.rb

@@ -1,8 +1,11 @@
-require 'dry/types/any'
+# frozen_string_literal: true
+
+require "dry/types/any"
 
 module Dry
   module Types
-    COERCIBLE = {
+    # Primitives with {Kernel} coercion methods
+    KERNEL_COERCIBLE = {
       string: String,
       integer: Integer,
       float: Float,
@@ -11,9 +14,19 @@ module Dry
       hash: ::Hash
     }.freeze
 
+    # 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,
@@ -23,44 +36,64 @@ module Dry
       range: Range
     }.freeze
 
-    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
+    # All built-in primitives
+    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
 
-    # Register built-in types that are non-coercible through kernel methods
+    # Register generic types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register(name.to_s, Definition[primitive].new(primitive))
+      type = Nominal[primitive].new(primitive)
+      register("nominal.#{name}", type)
     end
 
-    # Register strict built-in types that are non-coercible through kernel methods
+    # Register strict types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register("strict.#{name}", self[name.to_s].constrained(type: primitive))
+      type = self["nominal.#{name}"].constrained(type: primitive)
+      register(name.to_s, type)
+      register("strict.#{name}", type)
+    end
+
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
+      register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
-    # Register built-in primitive types with kernel coercion methods
-    COERCIBLE.each do |name, primitive|
-      register("coercible.#{name}", self[name.to_s].constructor(Kernel.method(primitive.name)))
+    # Register {METHOD_COERCIBLE} types
+    METHOD_COERCIBLE.each_key do |name|
+      register(
+        "coercible.#{name}", self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+      )
     end
 
-    # Register non-coercible optional types
+    # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
-      register("optional.strict.#{name}", self["strict.#{name}"].optional)
+      type = self[name.to_s].optional
+      register("optional.strict.#{name}", type)
+      register("optional.#{name}", type)
     end
 
-    # Register coercible optional types
+    # Register optional {COERCIBLE} 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 :(
-    register("bool", self["true"] | self["false"])
-    register("strict.bool", self["strict.true"] | self["strict.false"])
+    # 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("any", Any)
-    register("object", self['any'])
+    register("nominal.any", Any)
+    register("strict.any", Any)
   end
 end
 
-require 'dry/types/coercions'
-require 'dry/types/params'
-require 'dry/types/json'
+require "dry/types/coercions"
+require "dry/types/params"
+require "dry/types/json"

data/lib/dry/types/decorator.rb

@@ -1,7 +1,12 @@
-require 'dry/types/options'
+# frozen_string_literal: true
+
+require "dry/types/options"
 
 module Dry
   module Types
+    # Common API for types
+    #
+    # @api public
     module Decorator
       include Options
 
@@ -9,63 +14,76 @@ module Dry
       attr_reader :type
 
       # @param [Type] type
-      def initialize(type, *)
+      def initialize(type, *, **)
         super
         @type = type
       end
 
       # @param [Object] input
       # @param [#call, nil] block
+      #
       # @return [Result,Logic::Result]
       # @return [Object] if block given and try fails
+      #
+      # @api public
       def try(input, &block)
         type.try(input, &block)
       end
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        type.valid?(value)
-      end
-      alias_method :===, :valid?
-
       # @return [Boolean]
+      #
+      # @api public
       def default?
         type.default?
       end
 
       # @return [Boolean]
+      #
+      # @api public
       def constrained?
         type.constrained?
       end
 
-      # @return [Sum]
-      def optional
-        Types['strict.nil'] | self
-      end
-
       # @param [Symbol] meth
       # @param [Boolean] include_private
+      #
       # @return [Boolean]
+      #
+      # @api public
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        proc { |value| self.(value) }
+      end
+
       private
 
       # @param [Object] response
+      #
       # @return [Boolean]
+      #
+      # @api private
       def decorate?(response)
-        response.kind_of?(type.class)
+        response.is_a?(type.class)
       end
 
       # Delegates missing methods to {#type}
+      #
       # @param [Symbol] meth
       # @param [Array] args
       # @param [#call, nil] block
+      #
+      # @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)
@@ -76,10 +94,13 @@ module Dry
           super
         end
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
       # Replace underlying type
+      #
+      # @api private
       def __new__(type)
-        self.class.new(type, options)
+        self.class.new(type, *@__args__.drop(1), **@options)
       end
     end
   end

data/lib/dry/types/default.rb

@@ -1,30 +1,46 @@
-require 'dry/types/decorator'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/decorator"
 
 module Dry
   module Types
+    # Default types are useful when a missing value should be replaced by a default one
+    #
+    # @api public
     class Default
-      include Type
-      include Dry::Equalizer(:type, :options, :value)
-      include Decorator
-      include Builder
-
+      # @api private
       class Callable < Default
-        include Dry::Equalizer(:type, :options)
+        include Dry::Equalizer(:type, inspect: false, immutable: true)
 
         # Evaluates given callable
         # @return [Object]
         def evaluate
           value.call(type)
         end
+
+        # @return [true]
+        def callable?
+          true
+        end
       end
 
+      include Type
+      include Decorator
+      include Builder
+      include Printable
+      include Dry::Equalizer(:type, :value, inspect: false, immutable: true)
+
       # @return [Object]
       attr_reader :value
 
       alias_method :evaluate, :value
 
       # @param [Object, #call] value
+      #
       # @return [Class] {Default} or {Default::Callable}
+      #
+      # @api private
       def self.[](value)
         if value.respond_to?(:call)
           Callable
@@ -35,49 +51,78 @@ module Dry
 
       # @param [Type] type
       # @param [Object] value
+      #
+      # @api private
       def initialize(type, value, **options)
         super
         @value = value
       end
 
+      # Build a constrained type
+      #
       # @param [Array] args see {Dry::Types::Builder#constrained}
+      #
       # @return [Default]
+      #
+      # @api public
       def constrained(*args)
         type.constrained(*args).default(value)
       end
 
       # @return [true]
+      #
+      # @api public
       def default?
         true
       end
 
       # @param [Object] input
+      #
       # @return [Result::Success]
+      #
+      # @api public
       def try(input)
         success(call(input))
       end
 
+      # @return [Boolean]
+      #
+      # @api public
       def valid?(value = Undefined)
-        value.equal?(Undefined) || super
+        Undefined.equal?(value) || super
       end
 
       # @param [Object] input
+      #
       # @return [Object] value passed through {#type} or {#default} value
-      def call(input = Undefined)
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
         if input.equal?(Undefined)
           evaluate
         else
-          output = type[input]
-          output.nil? ? evaluate : output
+          Undefined.default(type.call_unsafe(input)) { evaluate }
         end
       end
-      alias_method :[], :call
 
-      private
+      # @param [Object] input
+      #
+      # @return [Object] value passed through {#type} or {#default} value
+      #
+      # @api private
+      def call_safe(input = Undefined, &block)
+        if input.equal?(Undefined)
+          evaluate
+        else
+          Undefined.default(type.call_safe(input, &block)) { evaluate }
+        end
+      end
 
-      # Replace underlying type
-      def __new__(type)
-        self.class.new(type, value, options)
+      # @return [false]
+      #
+      # @api private
+      def callable?
+        false
       end
     end
   end