dry-monads 1.3.5 → 1.5.0

data/lib/dry/monads/registry.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
-
 module Dry
   # Common, idiomatic monads for Ruby
   #
@@ -9,20 +7,20 @@ module Dry
   module Monads
     @registry = {}
     @constructors = nil
-    @paths = {
-      do: 'dry/monads/do/all',
-      lazy: 'dry/monads/lazy',
-      list: 'dry/monads/list',
-      maybe: 'dry/monads/maybe',
-      task: 'dry/monads/task',
-      try: 'dry/monads/try',
-      validated: 'dry/monads/validated',
+    @constants = {
+      do: "Do::All",
+      lazy: "Lazy",
+      list: "List",
+      maybe: "Maybe",
+      task: "Task",
+      try: "Try",
+      validated: "Validated",
       result: [
-        'dry/monads/result',
-        'dry/monads/result/fixed'
+        "Result",
+        "Result::Fixed"
       ]
     }.freeze
-    @mixins = Concurrent::Map.new
+    @mixins = ::Concurrent::Map.new
 
     class << self
       private
@@ -46,27 +44,29 @@ module Dry
 
       # @private
       def known_monads
-        @paths.keys
+        @constants.keys
       end
 
       # @private
       def load_monad(name)
-        path = @paths.fetch(name) {
-          raise ArgumentError, "#{name.inspect} is not a known monad"
+        constants = @constants.fetch(name) {
+          raise ::ArgumentError, "#{name.inspect} is not a known monad"
         }
-        Array(path).each { |p| require p }
+        Array(constants).each do |const_name|
+          const_name.split("::").reduce(Monads) { |mod, const| mod.const_get(const) }
+        end
       end
 
       # @private
       def constructors
-        @constructors ||= registry.values.map { |m|
+        @constructors ||= registry.values.filter_map { |m|
           m::Constructors if m.const_defined?(:Constructors)
-        }.compact
+        }
       end
 
       # @private
       def all_loaded?
-        registry.size == @paths.size
+        registry.size.eql?(@constants.size)
       end
     end
   end

data/lib/dry/monads/result/fixed.rb

@@ -1,37 +1,44 @@
 # frozen_string_literal: true
 
-module Dry::Monads
-  class Result
-    # @see Monads#Result
-    # @private
-    class Fixed < Module
-      def self.[](error, **options)
-        new(error, **options)
-      end
+require "dry/monads/constants"
+
+module Dry
+  module Monads
+    class Result
+      # @see Monads#Result
+      # @private
+      class Fixed < ::Module
+        def self.[](error, **options)
+          new(error, **options)
+        end
+
+        def initialize(error, **_options)
+          super()
 
-      def initialize(error, **_options)
-        @mod = Module.new do
-          define_method(:Failure) do |value|
-            if error === value
-              Failure.new(value, RightBiased::Left.trace_caller)
-            else
-              raise InvalidFailureTypeError, value
+          @mod = ::Module.new do
+            define_method(:Failure) do |value|
+              if error === value
+                Failure.new(value, RightBiased::Left.trace_caller)
+              else
+                # per https://github.com/dry-rb/dry-monads/pull/142
+                raise InvalidFailureTypeError.new(value)
+              end
             end
-          end
 
-          def Success(value = Undefined, &block)
-            v = Undefined.default(value, block || Unit)
-            Success.new(v)
+            def Success(value = Undefined, &block)
+              v = Undefined.default(value, block || Unit)
+              Success.new(v)
+            end
           end
         end
-      end
 
-      private
+        private
 
-      def included(base)
-        super
+        def included(base)
+          super
 
-        base.include(@mod)
+          base.include(@mod)
+        end
       end
     end
   end

data/lib/dry/monads/result.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-
-require 'dry/monads/constants'
-require 'dry/monads/right_biased'
-require 'dry/monads/transformer'
-require 'dry/monads/conversion_stubs'
-require 'dry/monads/unit'
-
 module Dry
   module Monads
     # Represents an operation which either succeeded or failed.
@@ -86,6 +78,7 @@ module Dry
 
         # @param value [Object] a value of a successful operation
         def initialize(value)
+          super()
           @value = value
         end
 
@@ -115,8 +108,8 @@ module Dry
         #
         # @param args [Array<Object>] arguments will be transparently passed through to #bind
         # @return [Result::Success]
-        def fmap(*args, &block)
-          Success.new(bind(*args, &block))
+        def fmap(...)
+          Success.new(bind(...))
         end
 
         # Returns result of applying first function to the internal value.
@@ -134,7 +127,7 @@ module Dry
         # @return [String]
         def to_s
           if Unit.equal?(@value)
-            'Success()'
+            "Success()"
           else
             "Success(#{@value.inspect})"
           end
@@ -147,6 +140,13 @@ module Dry
         def flip
           Failure.new(@value, RightBiased::Left.trace_caller)
         end
+
+        # Ignores values and returns self, see {Failure#alt_map}
+        #
+        # @return [Result::Success]
+        def alt_map(_ = nil)
+          self
+        end
       end
 
       # Represents a value of a failed operation.
@@ -156,7 +156,7 @@ module Dry
         include RightBiased::Left
         include Dry::Equalizer(:failure)
 
-        singleton_class.send(:alias_method, :call, :new)
+        singleton_class.alias_method(:call, :new)
 
         # Shortcut for Failure([...])
         #
@@ -188,6 +188,7 @@ module Dry
         # @param value [Object] failure value
         # @param trace [String] caller line
         def initialize(value, trace = RightBiased::Left.trace_caller)
+          super()
           @value = value
           @trace = trace
         end
@@ -218,7 +219,8 @@ module Dry
         # otherwise simply returns the first argument.
         #
         # @example
-        #   Dry::Monads.Failure(ArgumentError.new('error message')).or(&:message) # => "error message"
+        #   Dry::Monads.Failure(ArgumentError.new('error message')).or(&:message)
+        #   # => "error message"
         #
         # @param args [Array<Object>] arguments that will be passed to a block
         #                             if one was given, otherwise the first
@@ -232,7 +234,8 @@ module Dry
           end
         end
 
-        # A lifted version of `#or`. Wraps the passed value or the block result with Result::Success.
+        # A lifted version of `#or`. Wraps the passed value or the block
+        # result with Result::Success.
         #
         # @example
         #   Dry::Monads.Failure.new('no value').or_fmap('value') # => Success("value")
@@ -240,14 +243,14 @@ module Dry
         #
         # @param args [Array<Object>] arguments will be passed to the underlying `#or` call
         # @return [Result::Success] Wrapped value
-        def or_fmap(*args, &block)
-          Success.new(self.or(*args, &block))
+        def or_fmap(...)
+          Success.new(self.or(...))
         end
 
         # @return [String]
         def to_s
           if Unit.equal?(@value)
-            'Failure()'
+            "Failure()"
           else
             "Failure(#{@value.inspect})"
           end
@@ -287,6 +290,21 @@ module Dry
         def either(_, g)
           g.(failure)
         end
+
+        # Lifts a block/proc over Failure
+        #
+        # @overload alt_map(proc)
+        #   @param proc [#call]
+        #   @return [Result::Failure]
+        #
+        # @overload alt_map
+        #   @param block [Proc]
+        #   @return [Result::Failure]
+        #
+        def alt_map(proc = Undefined, &block)
+          f = Undefined.default(proc, block)
+          self.class.new(f.(failure), RightBiased::Left.trace_caller)
+        end
       end
 
       # A module that can be included for easier access to Result monads.
@@ -448,7 +466,7 @@ module Dry
       end
 
       class Invalid < Validated
-        # Concerts to Result::Failure
+        # Converts to Result::Failure
         #
         # @return [Result::Failure]
         def to_result
@@ -457,7 +475,7 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:result, Result::Mixin)
   end
 end

data/lib/dry/monads/right_biased.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/monads/constants'
-require 'dry/monads/unit'
-require 'dry/monads/curry'
-require 'dry/monads/errors'
-
 module Dry
   module Monads
     # A common module for right-biased monads, such as Result/Either, Maybe, and Try.
@@ -20,7 +15,7 @@ module Dry
           def m.to_proc
             @to_proc ||= method(:new).to_proc
           end
-          m.singleton_class.send(:alias_method, :call, :new)
+          m.singleton_class.alias_method(:call, :new)
         end
 
         # Unwraps the underlying value
@@ -70,8 +65,8 @@ module Dry
         #
         # @param [Array<Object>] args arguments will be transparently passed through to #bind
         # @return [RightBiased::Right]
-        def tee(*args, &block)
-          bind(*args, &block).bind { self }
+        def tee(...)
+          bind(...).bind { self }
         end
 
         # Abstract method for lifting a block over the monad type.
@@ -90,6 +85,16 @@ module Dry
           self
         end
 
+        # Ignores arguments and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Left}.
+        #
+        # @param _alt [RightBiased::Right, RightBiased::Left]
+        #
+        # @return [RightBiased::Right]
+        def |(_alt)
+          self
+        end
+
         # A lifted version of `#or`. For {RightBiased::Right} acts in the same way as `#or`,
         # that is returns itselt.
         #
@@ -118,18 +123,18 @@ module Dry
         #   create_user.apply(name) # => Failure(:name_missing)
         #
         # @return [RightBiased::Left,RightBiased::Right]
-        def apply(val = Undefined)
+        def apply(val = Undefined, &block)
           unless @value.respond_to?(:call)
             raise TypeError, "Cannot apply #{val.inspect} to #{@value.inspect}"
           end
 
-          Undefined.default(val) { yield }.fmap { |unwrapped| curry.(unwrapped) }
+          Undefined.default(val, &block).fmap { curry.(_1) }
         end
 
         # @param other [Object]
         # @return [Boolean]
         def ===(other)
-          self.class == other.class && value! === other.value!
+          other.instance_of?(self.class) && value! === other.value!
         end
 
         # Maps the value to Dry::Monads::Unit, useful when you don't care
@@ -197,11 +202,11 @@ module Dry
         # @api private
         def deconstruct
           if Unit.equal?(@value)
-            []
-          elsif @value.is_a?(::Array)
-            @value
-          else
+            EMPTY_ARRAY
+          elsif !@value.is_a?(::Array)
             [@value]
+          else
+            @value
           end
         end
 
@@ -226,19 +231,12 @@ module Dry
 
         private
 
-        if RUBY_VERSION >= '2.7'
-          # @api private
-          def destructure(value)
-            if value.is_a?(::Hash)
-              [EMPTY_ARRAY, value]
-            else
-              [[value], EMPTY_HASH]
-            end
-          end
-        else
-          # @api private
-          def destructure(*args, **kwargs)
-            [args, kwargs]
+        # @api private
+        def destructure(value)
+          if value.is_a?(::Hash)
+            [EMPTY_ARRAY, value]
+          else
+            [[value], EMPTY_HASH]
           end
         end
 
@@ -255,7 +253,7 @@ module Dry
         # @private
         # @return [String] Caller location
         def self.trace_caller
-          caller_locations(2, 2)[0].to_s
+          caller_locations(2, 1)[0].to_s
         end
 
         # Raises an error on accessing internal value
@@ -299,11 +297,20 @@ module Dry
           raise NotImplementedError
         end
 
+        # Returns the passed value. Works in pair with {RightBiased::Right#|}.
+        #
+        # @param alt [RightBiased::Right, RightBiased::Left]
+        #
+        # @return [RightBiased::Right, RightBiased::Left]
+        def |(alt)
+          self.or(alt)
+        end
+
         # A lifted version of `#or`. This is basically `#or` + `#fmap`.
         #
         # @example
-        #   Dry::Monads.None.or('no value') # => Some("no value")
-        #   Dry::Monads.None.or { Time.now } # => Some(current time)
+        #   Dry::Monads.None.or_fmap('no value') # => Some("no value")
+        #   Dry::Monads.None.or_fmap { Time.now } # => Some(current time)
         #
         # @return [RightBiased::Left, RightBiased::Right]
         def or_fmap(*)

data/lib/dry/monads/task.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/promise'
-
-require 'dry/monads/unit'
-require 'dry/monads/curry'
-require 'dry/monads/conversion_stubs'
+require "concurrent/promise"
 
 module Dry
   module Monads
@@ -15,7 +11,7 @@ module Dry
     # @api public
     class Task
       # @api private
-      class Promise < Concurrent::Promise
+      class Promise < ::Concurrent::Promise
         public :on_fulfill, :on_reject
       end
       private_constant :Promise
@@ -48,9 +44,11 @@ module Dry
         # @example using a predefined executor
         #    Task[:fast] { do_quick_task }
         #
-        # @param executor [Concurrent::AbstractExecutorService,Symbol] Either an executor instance
-        #                                                              or a name of predefined global
-        #                                                              from concurrent-ruby
+        # @param executor [Concurrent::AbstractExecutorService,Symbol]
+        #   Either an executor instance
+        #   or a name of predefined global
+        #   from concurrent-ruby
+        #
         # @return [Task]
         def [](executor, &block)
           new(Promise.execute(executor: executor, &block))
@@ -81,6 +79,7 @@ module Dry
       end
 
       include ConversionStubs[:to_maybe, :to_result]
+      extend ::Dry::Core::Deprecations[:"dry-monads"]
 
       # @api private
       attr_reader :promise
@@ -122,23 +121,23 @@ module Dry
       #                     and returns another task
       # @return [Task]
       def bind(&block)
-        self.class.new(promise.flat_map { |value| block.(value).promise })
+        self.class.new(promise.flat_map { block.(_1).promise })
       end
-      alias_method :then, :bind
+      deprecate :then, :bind
 
       # @return [String]
       def to_s
         state = case promise.state
                 when :fulfilled
                   if Unit.equal?(value!)
-                    'value=()'
+                    "value=()"
                   else
                     "value=#{value!.inspect}"
                   end
                 when :rejected
                   "error=#{promise.reason.inspect}"
                 else
-                  '?'
+                  "?"
                 end
 
         "Task(#{state})"
@@ -164,16 +163,14 @@ module Dry
         )
 
         promise.on_error do |v|
-          begin
-            inner = block.(v).promise
-            inner.execute
-            inner.on_success { |r| child.on_fulfill(r) }
-            inner.on_error { |e| child.on_reject(e) }
-          rescue StandardError => e
-            child.on_reject(e)
-          end
+          inner = block.(v).promise
+          inner.execute
+          inner.on_success { child.on_fulfill(_1) }
+          inner.on_error { child.on_reject(_1) }
+        rescue StandardError => e
+          child.on_reject(e)
         end
-        promise.on_success { |v| child.on_fulfill(v) }
+        promise.on_success { child.on_fulfill(_1) }
 
         self.class.new(child)
       end
@@ -236,9 +233,9 @@ module Dry
       #
       # @param val [Task]
       # @return [Task]
-      def apply(val = Undefined)
-        arg = Undefined.default(val) { yield }
-        bind { |f| arg.fmap { |v| curry(f).(v) } }
+      def apply(val = Undefined, &block)
+        arg = Undefined.default(val, &block)
+        bind { |f| arg.fmap { curry(f).(_1) } }
       end
 
       # Maps a successful result to Unit, effectively discards it
@@ -267,8 +264,8 @@ module Dry
       # @api private
       def compare_promises(x, y)
         x.equal?(y) ||
-          x.fulfilled? && y.fulfilled? && x.value == y.value ||
-          x.rejected? && y.rejected? && x.reason == y.reason
+          (x.fulfilled? && y.fulfilled? && x.value == y.value) ||
+          (x.rejected? && y.rejected? && x.reason == y.reason)
       end
 
       # Task constructors.
@@ -314,7 +311,7 @@ module Dry
       end
     end
 
-    require 'dry/monads/registry'
+    require "dry/monads/registry"
     register_mixin(:task, Task::Mixin)
   end
 end

data/lib/dry/monads/transformer.rb

@@ -27,7 +27,8 @@ module Dry
       # Lifts a block/proc over the 3-level nested structure.
       #
       # @example
-      #   List[Right(Some(1)), Left(Some(1))].fmap3 { |x| x + 1 } # => List[Right(Some(2)), Left(Some(1))]
+      #   List[Right(Some(1)), Left(Some(1))].fmap3 { |x| x + 1 }
+      #   # => List[Right(Some(2)), Left(Some(1))]
       #   Right(None).fmap3 { |x| x + 1 } # => Right(None)
       #
       # @param args [Array<Object>] arguments will be passed to the block or the proc

data/lib/dry/monads/traverse.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/monads/validated'
+# rubocop:disable Naming/ConstantName
+# rubocop:disable Style/MutableConstant
 
 module Dry
   module Monads
@@ -20,3 +21,6 @@ module Dry
     Traverse.freeze
   end
 end
+
+# rubocop:enable Style/MutableConstant
+# rubocop:enable Naming/ConstantName