dry-monads 1.3.5 → 1.5.0

data/lib/dry/monads/do/all.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/monads/do'
-
 module Dry
   module Monads
     module Do
@@ -68,9 +66,10 @@ module Dry
             tracker = self
 
             module_eval do
+              private
+
               define_method(:method_added) do |method|
                 super(method)
-
                 tracker.wrap_method(self, method)
               end
 
@@ -93,20 +92,37 @@ module Dry
           end
 
           def wrap_method(target, method)
-            Do.wrap_method(wrappers[target], method)
+            visibility = Do.method_visibility(target, method)
+            Do.wrap_method(wrappers[target], method, visibility)
           end
         end
 
-        # @api private
-        def self.included(base)
-          super
+        class << self
+          # @api private
+          def included(base)
+            super
+
+            wrappers = ::Hash.new { _1[_2] = ::Module.new }
+            tracker = MethodTracker.new(wrappers)
+            base.extend(tracker)
+            base.extend(InstanceMixin) unless base.is_a?(::Class)
+            wrap_defined_methods(base, wrappers[base])
+          end
 
-          wrappers = ::Hash.new { |h, k| h[k] = ::Module.new }
-          tracker = MethodTracker.new(wrappers)
-          base.extend(tracker)
-          base.instance_methods(false).each { |m| tracker.wrap_method(base, m) }
+          # @api private
+          def wrap_defined_methods(klass, target)
+            klass.public_instance_methods(false).each do |m|
+              Do.wrap_method(target, m, :public)
+            end
+
+            klass.protected_instance_methods(false).each do |m|
+              Do.wrap_method(target, m, :protected)
+            end
 
-          base.extend(InstanceMixin) unless base.is_a?(::Class)
+            klass.private_instance_methods(false).each do |m|
+              Do.wrap_method(target, m, :private)
+            end
+          end
         end
 
         # @api private
@@ -116,17 +132,18 @@ module Dry
             super
 
             wrapper = ::Module.new
-            object.singleton_class.prepend(wrapper)
+            eigenclass = object.singleton_class
+            eigenclass.prepend(wrapper)
             object.define_singleton_method(:singleton_method_added) do |method|
               super(method)
 
               next if method.equal?(:singleton_method_added)
 
-              Do.wrap_method(wrapper, method)
-            end
-            object.singleton_class.instance_methods(false).each do |m|
-              Do.wrap_method(wrapper, m)
+              visibility = Do.method_visibility(eigenclass, method)
+              Do.wrap_method(wrapper, method, visibility)
             end
+
+            All.wrap_defined_methods(eigenclass, wrapper)
           end
         end
 
@@ -134,7 +151,7 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:do, Do::All)
   end
 end

data/lib/dry/monads/do.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/monads/list'
-require 'dry/monads/do/mixin'
-require 'dry/monads/constants'
-
 module Dry
   module Monads
     # An implementation of do-notation.
@@ -12,7 +8,11 @@ module Dry
     module Do
       extend Mixin
 
-      DELEGATE = ::RUBY_VERSION < '2.7' ? '*' : '...'
+      VISIBILITY_WORD = {
+        public: "",
+        private: "private ",
+        protected: "protected "
+      }.freeze
 
       # @api private
       class Halt < StandardError
@@ -26,6 +26,25 @@ module Dry
         end
       end
 
+      # @api private
+      class MethodTracker < ::Module
+        # @api private
+        def initialize(tracked_methods, base, wrapper)
+          module_eval do
+            private
+
+            define_method(:method_added) do |method|
+              super(method)
+
+              if tracked_methods.include?(method)
+                visibility = Do.method_visibility(base, method)
+                Do.wrap_method(wrapper, method, visibility)
+              end
+            end
+          end
+        end
+      end
+
       class << self
         # Generates a module that passes a block to methods
         # that either unwraps a single-valued monadic value or halts
@@ -84,13 +103,11 @@ module Dry
         # @param [Array<Symbol>] methods
         # @return [Module]
         def for(*methods)
-          mod = ::Module.new do
-            methods.each { |method_name| Do.wrap_method(self, method_name) }
-          end
-
           ::Module.new do
-            singleton_class.send(:define_method, :included) do |base|
+            singleton_class.define_method(:included) do |base|
+              mod = ::Module.new
               base.prepend(mod)
+              base.extend(MethodTracker.new(methods, base, mod))
             end
           end
         end
@@ -100,23 +117,34 @@ module Dry
           super
 
           # Actually mixes in Do::All
-          require 'dry/monads/do/all'
+          require "dry/monads/do/all"
           base.include All
         end
 
         # @api private
-        def wrap_method(target, method_name)
+        def wrap_method(target, method, visibility)
           target.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def #{method_name}(#{DELEGATE})
-              if block_given?
-                super
-              else
-                Do.() { super { |*ms| Do.bind(ms) } }
-              end
-            end
+            #{VISIBILITY_WORD[visibility]} def #{method}(...) # private def create_acccount(...)
+              if block_given?                                 #   if block_given?
+                super                                         #     super
+              else                                            #   else
+                Do.() { super { |*ms| Do.bind(ms) } }         #     Do.() { super { |*ms| Do.bind(ms) } }
+              end                                             #   end
+            end                                               # end
           RUBY
         end
 
+        # @api private
+        def method_visibility(mod, method)
+          if mod.public_method_defined?(method)
+            :public
+          elsif mod.private_method_defined?(method)
+            :private
+          else
+            :protected
+          end
+        end
+
         # @api private
         def coerce_to_monad(monads)
           return monads if monads.size != 1
@@ -135,7 +163,7 @@ module Dry
 
         # @api private
         def halt(result)
-          raise Halt.new(result), EMPTY_STRING, []
+          raise Halt.new(result), "", []
         end
       end
     end

data/lib/dry/monads/errors.rb

@@ -3,21 +3,24 @@
 module Dry
   module Monads
     # An unsuccessful result of extracting a value from a monad.
-    class UnwrapError < StandardError
-      def initialize(ctx)
-        super("value! was called on #{ctx.inspect}")
+    class UnwrapError < ::StandardError
+      attr_reader :receiver
+
+      def initialize(receiver)
+        @receiver = receiver
+        super("value! was called on #{receiver.inspect}")
       end
     end
 
     # An error thrown on returning a Failure of unknown type.
-    class InvalidFailureTypeError < StandardError
+    class InvalidFailureTypeError < ::StandardError
       def initialize(failure)
         super("Cannot create Failure from #{failure.inspect}, it doesn't meet the constraints")
       end
     end
 
     # Improper use of None
-    class ConstructorNotAppliedError < NoMethodError
+    class ConstructorNotAppliedError < ::NoMethodError
       def initialize(method_name, constructor_name)
         super(
           "For calling .#{method_name} on #{constructor_name}() build a value "\

data/lib/dry/monads/lazy.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/promise'
-
-require 'dry/monads/task'
+require "concurrent/promise"
 
 module Dry
   module Monads
@@ -11,6 +9,8 @@ module Dry
     # computation is evaluated not more than once (compare with the built-in
     # lazy assignement ||= which does not guarantee this).
     class Lazy < Task
+      extend ::Dry::Core::Deprecations[:"dry-monads"]
+
       class << self
         # @private
         def new(promise = nil, &block)
@@ -41,6 +41,14 @@ module Dry
         self
       end
 
+      # @return [Boolean]
+      def evaluated?
+        @promise.complete?
+      end
+      deprecate :complete?, :evaluated?
+
+      undef_method :wait
+
       # @return [String]
       def to_s
         state = case promise.state
@@ -49,7 +57,7 @@ module Dry
                 when :rejected
                   "!#{promise.reason.inspect}"
                 else
-                  '?'
+                  "?"
                 end
 
         "Lazy(#{state})"
@@ -80,7 +88,7 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:lazy, Lazy::Mixin)
   end
 end

data/lib/dry/monads/list.rb

@@ -1,15 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-
-require 'dry/monads/maybe'
-require 'dry/monads/task'
-require 'dry/monads/result'
-require 'dry/monads/try'
-require 'dry/monads/validated'
-require 'dry/monads/transformer'
-require 'dry/monads/curry'
-
 module Dry
   module Monads
     # The List monad.
@@ -83,7 +73,7 @@ module Dry
         end
       end
 
-      extend Dry::Core::Deprecations[:'dry-monads']
+      extend Dry::Core::Deprecations[:"dry-monads"]
 
       include Dry::Equalizer(:value, :type)
       include Transformer
@@ -110,10 +100,10 @@ module Dry
       # @return [List]
       def bind(*args)
         if block_given?
-          List.coerce(value.map { |v| yield(v, *args) }.reduce([], &:+))
+          List.coerce(value.map { yield(_1, *args) }.reduce([], &:+))
         else
           obj, *rest = args
-          List.coerce(value.map { |v| obj.(v, *rest) }.reduce([], &:+))
+          List.coerce(value.map { obj.(_1, *rest) }.reduce([], &:+))
         end
       end
 
@@ -128,22 +118,22 @@ module Dry
       # @return [List]
       def fmap(*args)
         if block_given?
-          List.new(value.map { |v| yield(v, *args) })
+          List.new(value.map { yield(_1, *args) })
         else
           obj, *rest = args
-          List.new(value.map { |v| obj.(v, *rest) })
+          List.new(value.map { obj.(_1, *rest) })
         end
       end
 
       # Maps a block over the list. Acts as `Array#map`.
-      # Note that this method returns an Array instance, not a List
+      # If called without a block, this method returns an enumerator, not a List
       #
       # @return [List,Enumerator]
       def map(&block)
-        if block
+        if block_given?
           fmap(block)
         else
-          value.map(&block)
+          value.map
         end
       end
 
@@ -165,7 +155,7 @@ module Dry
       #
       # @return [String]
       def inspect
-        type_ann = typed? ? "<#{type.name.split('::').last}>" : ''
+        type_ann = typed? ? "<#{type.name.split("::").last}>" : ""
         "List#{type_ann}#{value.inspect}"
       end
       alias_method :to_s, :inspect
@@ -192,8 +182,8 @@ module Dry
       #
       # @param initial [Object] Initial value
       # @return [Object]
-      def fold_left(initial)
-        value.reduce(initial) { |acc, v| yield(acc, v) }
+      def fold_left(initial, &block)
+        value.reduce(initial, &block)
       end
       alias_method :foldl, :fold_left
       alias_method :reduce, :fold_left
@@ -224,8 +214,8 @@ module Dry
       # Filters elements with a block
       #
       # @return [List]
-      def filter
-        coerce(value.select { |e| yield(e) })
+      def filter(&block)
+        coerce(value.select(&block))
       end
       alias_method :select, :filter
 
@@ -265,12 +255,12 @@ module Dry
       def typed(type = nil)
         if type.nil?
           if size.zero?
-            raise ArgumentError, 'Cannot infer a monad for an empty list'
+            raise ArgumentError, "Cannot infer a monad for an empty list"
           else
             self.class.warn(
-              'Automatic monad inference is deprecated, pass a type explicitly '\
+              "Automatic monad inference is deprecated, pass a type explicitly "\
               "or use a predefined constant, e.g. List::Result\n"\
-              "#{caller.find { |l| l !~ %r{(lib/dry/monads)|(gems)} }}"
+              "#{caller.find { _1 !~ %r{(lib/dry/monads)|(gems)} }}"
             )
             self.class.new(value, value[0].monad)
           end
@@ -298,7 +288,7 @@ module Dry
       # @return [Monad] Result is a monadic value
       def traverse(proc = nil, &block)
         unless typed?
-          raise StandardError, 'Cannot traverse an untyped list'
+          raise StandardError, "Cannot traverse an untyped list"
         end
 
         cons = type.pure { |list, i| list + List.pure(i) }
@@ -315,9 +305,9 @@ module Dry
       #
       # @param list [List]
       # @return [List]
-      def apply(list = Undefined)
-        v = Undefined.default(list) { yield }
-        fmap(Curry).bind { |f| v.fmap { |x| f.(x) } }
+      def apply(list = Undefined, &block)
+        v = Undefined.default(list, &block)
+        fmap(Curry).bind { |f| v.fmap { f.(_1) } }
       end
 
       # Returns the List monad.
@@ -329,7 +319,7 @@ module Dry
 
       # Returns self.
       #
-      # @return [Result::Success, Result::Failure]
+      # @return [List]
       def to_monad
         self
       end
@@ -345,7 +335,7 @@ module Dry
       #       Some(n / divisor)
       #     end
       #   end
-      #   # => List[4, 2]
+      #   # => List[2, 4]
       #
       # @example without block
       #   List[Some(5), None(), Some(3)].collect.map { |x| x * 2 }
@@ -362,7 +352,7 @@ module Dry
           List.new(collected)
         else
           Enumerator.new do |g|
-            value.each { |x| g << x.value! if x.some? }
+            value.each { g << _1.value! if _1.some? }
           end
         end
       end
@@ -422,10 +412,10 @@ module Dry
       # List of results
       Result = ListBuilder[Result]
 
-      # List of results
+      # List of maybes
       Maybe = ListBuilder[Maybe]
 
-      # List of results
+      # List of tries
       Try = ListBuilder[Try]
 
       # List of validation results
@@ -449,9 +439,9 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:list, List::Mixin)
   end
 end
 
-require 'dry/monads/traverse'
+require "dry/monads/traverse"

data/lib/dry/monads/maybe.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/core/deprecations'
-
-require 'dry/monads/right_biased'
-require 'dry/monads/transformer'
-require 'dry/monads/unit'
-require 'dry/monads/constants'
-
 module Dry
   module Monads
     # Represents a value which can exist or not, i.e. it could be nil.
@@ -15,9 +7,13 @@ module Dry
     # @api public
     class Maybe
       include Transformer
+      extend Core::ClassAttributes
+
+      defines :warn_on_implicit_nil_coercion
+      warn_on_implicit_nil_coercion true
 
       class << self
-        extend Core::Deprecations[:'dry-monads']
+        extend Core::Deprecations[:"dry-monads"]
 
         # Wraps the given value with into a Maybe object.
         #
@@ -105,7 +101,9 @@ module Dry
         end
 
         def initialize(value = Undefined)
-          raise ArgumentError, 'nil cannot be some' if value.nil?
+          raise ArgumentError, "nil cannot be some" if value.nil?
+
+          super()
 
           @value = Undefined.default(value, Unit)
         end
@@ -120,15 +118,66 @@ module Dry
         # @param args [Array<Object>] arguments will be transparently passed through to #bind
         # @return [Maybe::Some, Maybe::None] Wrapped result, i.e. nil will be mapped to None,
         #                                    other values will be wrapped with Some
-        def fmap(*args, &block)
-          Maybe.coerce(bind(*args, &block))
+        def fmap(...)
+          next_value = bind(...)
+
+          if next_value.nil?
+            if self.class.warn_on_implicit_nil_coercion
+              Core::Deprecations.warn(
+                "Block passed to Some#fmap returned `nil` and was chained to None. "\
+                "This is literally an unlawful behavior and it will not be supported in "\
+                "dry-monads 2. \nPlease, replace `.fmap` with `.maybe` in places where you "\
+                "expect `nil` as block result.\n"\
+                "You can opt out of these warnings with\n"\
+                "Dry::Monads::Maybe.warn_on_implicit_nil_coercion false",
+                uplevel: 0,
+                tag: :"dry-monads"
+              )
+            end
+            Monads.None()
+          else
+            Some.new(next_value)
+          end
+        end
+
+        # Does the same thing as #bind except it also wraps the value
+        # in an instance of the Maybe monad. This allows for easier
+        # chaining of calls.
+        #
+        # @example
+        #   Dry::Monads.Some(4).maybe(&:succ).maybe(->(n) { n**2 }) # => Some(25)
+        #   Dry::Monads.Some(4).maybe(&:succ).maybe(->(_) { nil }) # => None()
+        #
+        # @param args [Array<Object>] arguments will be transparently passed through to #bind
+        # @return [Maybe::Some, Maybe::None] Wrapped result, i.e. nil will be mapped to None,
+        #                                    other values will be wrapped with Some
+        def maybe(...)
+          Maybe.coerce(bind(...))
+        end
+
+        # Accepts a block and runs it against the wrapped value.
+        # If the block returns a trurhy value the result is self,
+        # otherwise None. If no block is given, the value serves
+        # and its result.
+        #
+        # @param with [#call] positional block
+        # @param block [Proc] block
+        #
+        # @return [Maybe::None, Maybe::Some]
+        def filter(with = Undefined, &block)
+          block = Undefined.default(with, block || IDENTITY)
+
+          if block.(@value)
+            self
+          else
+            Monads.None()
+          end
         end
-        alias_method :maybe, :fmap
 
         # @return [String]
         def to_s
           if Unit.equal?(@value)
-            'Some()'
+            "Some()"
           else
             "Some(#{@value.inspect})"
           end
@@ -143,10 +192,10 @@ module Dry
         include RightBiased::Left
 
         @instance = new.freeze
-        singleton_class.send(:attr_reader, :instance)
+        singleton_class.attr_reader(:instance)
 
         # @api private
-        def self.method_missing(m, *)
+        def self.method_missing(m, *) # rubocop:disable Style/MissingRespondToMissing
           if (instance.methods(true) - methods(true)).include?(m)
             raise ConstructorNotAppliedError.new(m, :None)
           else
@@ -161,6 +210,7 @@ module Dry
         attr_reader :trace
 
         def initialize(trace = RightBiased::Left.trace_caller)
+          super()
           @trace = trace
         end
 
@@ -196,13 +246,13 @@ module Dry
         # @param args [Array<Object>] arguments will be passed to the underlying `#or` call
         # @return [Maybe::Some, Maybe::None] Lifted `#or` result, i.e. nil will be mapped to None,
         #                                    other values will be wrapped with Some
-        def or_fmap(*args, &block)
-          Maybe.coerce(self.or(*args, &block))
+        def or_fmap(...)
+          Maybe.coerce(self.or(...))
         end
 
         # @return [String]
         def to_s
-          'None'
+          "None"
         end
         alias_method :inspect, :to_s
 
@@ -230,6 +280,13 @@ module Dry
         def deconstruct
           EMPTY_ARRAY
         end
+
+        # @see Maybe::Some#filter
+        #
+        # @return [Maybe::None]
+        def filter(_ = Undefined)
+          self
+        end
       end
 
       # A module that can be included for easier access to Maybe monads.
@@ -301,9 +358,9 @@ module Dry
         # None values are removed
         #
         # @example
-        #   Maybe::Hash.filter(foo: Some(1), bar: Some(2)) # => Some(foo: 1, bar: 2)
-        #   Maybe::Hash.filter(foo: Some(1), bar: None())  # => None()
-        #   Maybe::Hash.filter(foo: None(), bar: Some(2))  # => None()
+        #   Maybe::Hash.filter(foo: Some(1), bar: Some(2)) # => { foo: 1, bar: 2 }
+        #   Maybe::Hash.filter(foo: Some(1), bar: None())  # => { foo: 1 }
+        #   Maybe::Hash.filter(foo: None(), bar: Some(2))  # => { bar: 2 }
         #
         # @param hash [::Hash<Object,Maybe>]
         # @return [::Hash]
@@ -325,10 +382,12 @@ module Dry
 
     class Result
       class Success < Result
-        # @return [Maybe::Some]
+        extend Core::Deprecations[:"dry-monads"]
+
+        # @return [Maybe]
         def to_maybe
-          Kernel.warn 'Success(nil) transformed to None' if @value.nil?
-          Dry::Monads::Maybe(@value)
+          warn "Success(nil) transformed to None" if @value.nil?
+          ::Dry::Monads::Maybe(@value)
         end
       end
 
@@ -389,7 +448,7 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:maybe, Maybe::Mixin)
   end
 end