dry-types 1.1.0 → 1.2.0

data/docsite/source/map.html.md

@@ -0,0 +1,17 @@
+---
+title: Map
+layout: gem-single
+name: dry-types
+---
+
+`Map` describes a homogeneous hashmap. This means only types of keys and values are known. You can simply imagine a map input as a list of key-value pairs.
+
+```ruby
+int_float_hash = Types::Hash.map(Types::Integer, Types::Float)
+int_float_hash[100 => 300.0, 42 => 70.0]
+# => {100=>300.0, 42=>70.0}
+
+# Only accepts mappings of integers to floats
+int_float_hash[name: 'Jane']
+# => Dry::Types::MapError: input key :name is invalid: type?(Integer, :name)
+```

data/docsite/source/optional-values.html.md

@@ -0,0 +1,96 @@
+---
+title: Type Attributes
+layout: gem-single
+name: dry-types
+---
+
+Types themselves have optional attributes you can apply to get further functionality.
+
+### Append `.optional` to a _Type_ to allow `nil` 
+
+By default, nil values raise an error:
+
+``` ruby
+Types::Strict::String[nil]
+# => raises Dry::Types::ConstraintError
+```
+
+Add `.optional` and `nil` values become valid:
+
+```ruby
+optional_string = Types::Strict::String.optional
+
+optional_string[nil]
+# => nil
+optional_string['something']
+# => "something"
+optional_string[123]
+# raises Dry::Types::ConstraintError
+```
+
+`Types::String.optional` is just syntactic sugar for `Types::Strict::Nil | Types::Strict::String`.
+
+### Handle optional values using Monads
+
+The [dry-monads gem](/gems/dry-monads/) provides another approach to handling optional values by returning a [_Monad_](/gems/dry-monads/) object. This allows you to pass your type to a `Maybe(x)` block that only executes if `x` returns `Some` or `None`.
+
+> NOTE: Requires the [dry-monads gem](/gems/dry-monads/) to be loaded.
+
+1. Load the `:maybe` extension in your application.
+
+    ```ruby
+    require 'dry-types'
+    
+    Dry::Types.load_extensions(:maybe)
+    module Types
+      include Dry.Types()
+    end
+    ```
+   
+2. Append `.maybe` to a _Type_ to return a _Monad_ object  
+
+```ruby
+x = Types::Maybe::Strict::Integer[nil]
+Maybe(x) { puts(x) }
+
+x = Types::Maybe::Coercible::String[nil]
+Maybe(x) { puts(x) }
+
+x = Types::Maybe::Strict::Integer[123]
+Maybe(x) { puts(x) }
+
+x = Types::Maybe::Strict::String[123]
+Maybe(x) { puts(x) }
+```
+
+```ruby
+Types::Maybe::Strict::Integer[nil] # None
+Types::Maybe::Strict::Integer[123] # Some(123)
+
+Types::Maybe::Coercible::Float[nil] # None
+Types::Maybe::Coercible::Float['12.3'] # Some(12.3)
+
+# 'Maybe' types can also accessed by calling '.maybe' on a regular type:
+Types::Strict::Integer.maybe # equivalent to Types::Maybe::Strict::Integer
+```
+
+You can define your own optional types:
+
+``` ruby
+maybe_string = Types::Strict::String.maybe
+
+maybe_string[nil]
+# => None
+
+maybe_string[nil].fmap(&:upcase)
+# => None
+
+maybe_string['something']
+# => Some('something')
+
+maybe_string['something'].fmap(&:upcase)
+# => Some('SOMETHING')
+
+maybe_string['something'].fmap(&:upcase).value_or('NOTHING')
+# => "SOMETHING"
+```

data/docsite/source/sum.html.md

@@ -0,0 +1,21 @@
+---
+title: Sum
+layout: gem-single
+name: dry-types
+order: 7
+---
+
+You can specify sum types using `|` operator, it is an explicit way of defining what the valid types of a value are.
+
+For example `dry-types` defines the `Bool` type which is a sum consisting of the `True` and `False` types, expressed as `Types::True | Types::False`.
+
+Another common case is defining that something can be either `nil` or something else:
+
+``` ruby
+nil_or_string = Types::Nil | Types::String
+
+nil_or_string[nil] # => nil
+nil_or_string["hello"] # => "hello"
+
+nil_or_string[123] # raises Dry::Types::ConstraintError
+```

data/lib/dry/types.rb

@@ -89,7 +89,7 @@ module Dry
     def self.[](name)
       type_map.fetch_or_store(name) do
         case name
-        when String
+        when ::String
           result = name.match(TYPE_SPEC_REGEX)
 
           if result
@@ -98,7 +98,12 @@ module Dry
           else
             container[name]
           end
-        when Class
+        when ::Class
+          warn(<<~DEPRECATION)
+            Using Dry::Types.[] with a class is deprecated, please use string identifiers: Dry::Types[Integer] -> Dry::Types['integer'].
+            If you're using dry-struct this means changing `attribute :counter, Integer` to `attribute :counter, Dry::Types['integer']` or to `attribute :counter, 'integer'`.
+          DEPRECATION
+
           type_name = identifier(name)
 
           if container.key?(type_name)

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

@@ -100,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

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,7 +115,7 @@ 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

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
@@ -182,7 +155,7 @@ 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 response.is_a?(Type) && type.class == response.class
             response.constructor_type.new(response, options)

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/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

data/lib/dry/types/extensions/monads.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+
+module Dry
+  module Types
+    # Monad extension for Result
+    #
+    # @api public
+    class Result
+      include Dry::Monads::Result::Mixin
+
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
+        if success?
+          Success(input)
+        else
+          Failure([error, input])
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -121,7 +121,8 @@ module Dry
       # @api private
       def resolve_type(type)
         case type
-        when String, Class then Types[type]
+        when Type then type
+        when ::Class, ::String then Types[type]
         else type
         end
       end

data/lib/dry/types/lax.rb

@@ -15,7 +15,7 @@ module Dry
       include Printable
       include Dry::Equalizer(:type, inspect: false)
 
-      private :options, :constructor
+      undef :options, :constructor
 
       # @param [Object] input
       #

data/lib/dry/types/params.rb

@@ -55,5 +55,10 @@ module Dry
     register('params.symbol') do
       self['nominal.symbol'].constructor(Coercions::Params.method(:to_symbol))
     end
+
+    COERCIBLE.each_key do |name|
+      next if name.equal?(:string)
+      register("optional.params.#{name}", self['params.nil'] | self["params.#{name}"])
+    end
   end
 end

data/lib/dry/types/predicate_inferrer.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'dry/core/cache'
+require 'dry/types/predicate_registry'
+
+module Dry
+  module Types
+    # PredicateInferrer returns the list of predicates used by a type.
+    #
+    # @api public
+    class PredicateInferrer
+      extend Core::Cache
+
+      TYPE_TO_PREDICATE = {
+        DateTime => :date_time?,
+        FalseClass => :false?,
+        Integer => :int?,
+        NilClass => :nil?,
+        String => :str?,
+        TrueClass => :true?,
+        BigDecimal => :decimal?
+      }.freeze
+
+      REDUCED_TYPES = {
+        [[[:true?], [:false?]]] => %i[bool?]
+      }.freeze
+
+      HASH = %i[hash?].freeze
+
+      ARRAY = %i[array?].freeze
+
+      NIL = %i[nil?].freeze
+
+      # Compiler reduces type AST into a list of predicates
+      #
+      # @api private
+      class Compiler
+        # @return [PredicateRegistry]
+        # @api private
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @api private
+        def infer_predicate(type)
+          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
+        end
+
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type = node[0]
+          predicate = infer_predicate(type)
+
+          if registry.key?(predicate[0])
+            predicate
+          else
+            [type?: type]
+          end
+        end
+
+        # @api private
+        def visit_hash(_)
+          HASH
+        end
+
+        # @api private
+        def visit_array(_)
+          ARRAY
+        end
+
+        # @api private
+        def visit_lax(node)
+          visit(node)
+        end
+
+        # @api private
+        def visit_constructor(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_enum(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_sum(node)
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
+
+          if left.eql?(NIL)
+            right
+          else
+            [[left, right]]
+          end
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, rules = node
+          predicates = visit(rules)
+
+          if predicates.empty?
+            visit(other)
+          else
+            [*visit(other), *merge_predicates(predicates)]
+          end
+        end
+
+        # @api private
+        def visit_any(_)
+          EMPTY_ARRAY
+        end
+
+        # @api private
+        def visit_and(node)
+          left, right = node
+          visit(left) + visit(right)
+        end
+
+        # @api private
+        def visit_predicate(node)
+          pred, args = node
+
+          if pred.equal?(:type?)
+            EMPTY_ARRAY
+          elsif registry.key?(pred)
+            *curried, _ = args
+            values = curried.map { |_, v| v }
+
+            if values.empty?
+              [pred]
+            else
+              [pred => values[0]]
+            end
+          else
+            EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_predicates(nodes)
+          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
+            if predicate.is_a?(::Hash)
+              h.update(predicate)
+            else
+              ps << predicate
+            end
+          end
+
+          merged.empty? ? preds : [*preds, merged]
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize(registry = PredicateRegistry.new)
+        @compiler = Compiler.new(registry)
+      end
+
+      # Infer predicate identifier from the provided type
+      #
+      # @param [Type] type
+      # @return [Symbol]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          predicates = compiler.visit(type.to_ast)
+
+          if predicates.is_a?(::Hash)
+            predicates
+          else
+            REDUCED_TYPES[predicates] || predicates
+          end
+        end
+      end
+    end
+  end
+end