dry-monads 1.6.0 → 1.7.0

data/lib/dry/monads/result.rb

@@ -34,31 +34,25 @@ module Dry
       # Returns self, added to keep the interface compatible with other monads.
       #
       # @return [Result::Success, Result::Failure]
-      def to_result
-        self
-      end
+      def to_result = self
 
       # Returns self.
       #
       # @return [Result::Success, Result::Failure]
-      def to_monad
-        self
-      end
+      def to_monad = self
 
       # Returns the Result monad.
       # This is how we're doing polymorphism in Ruby 😕
       #
       # @return [Monad]
-      def monad
-        Result
-      end
+      def monad = Result
 
       # Represents a value of a successful operation.
       #
       # @api public
       class Success < Result
         include RightBiased::Right
-        include Dry::Equalizer(:value!)
+        include ::Dry::Equalizer(:value!)
 
         # Shortcut for Success([...])
         #
@@ -70,9 +64,7 @@ module Dry
         #    end
         #
         # @api public
-        def self.[](*value)
-          new(value)
-        end
+        def self.[](*value) = new(value)
 
         alias_method :success, :value!
 
@@ -85,19 +77,13 @@ module Dry
         # Apply the second function to value.
         #
         # @api public
-        def result(_, f)
-          f.(@value)
-        end
+        def result(_, f) = f.(@value)
 
         # Returns false
-        def failure?
-          false
-        end
+        def failure? = false
 
         # Returns true
-        def success?
-          true
-        end
+        def success? = true
 
         # Does the same thing as #bind except it also wraps the value
         # in an instance of Result::Success monad. This allows for easier
@@ -108,9 +94,7 @@ module Dry
         #
         # @param args [Array<Object>] arguments will be transparently passed through to #bind
         # @return [Result::Success]
-        def fmap(...)
-          Success.new(bind(...))
-        end
+        def fmap(...) = Success.new(bind(...))
 
         # Returns result of applying first function to the internal value.
         #
@@ -120,9 +104,7 @@ module Dry
         # @param f [#call] Function to apply
         # @param _ [#call] Ignored
         # @return [Any] Return value of `f`
-        def either(f, _)
-          f.(success)
-        end
+        def either(f, _) = f.(success)
 
         # @return [String]
         def to_s
@@ -144,9 +126,7 @@ module Dry
         # Ignores values and returns self, see {Failure#alt_map}
         #
         # @return [Result::Success]
-        def alt_map(_ = nil)
-          self
-        end
+        def alt_map(_ = nil) = self
       end
 
       # Represents a value of a failed operation.
@@ -154,7 +134,7 @@ module Dry
       # @api public
       class Failure < Result
         include RightBiased::Left
-        include Dry::Equalizer(:failure)
+        include ::Dry::Equalizer(:failure)
 
         singleton_class.alias_method(:call, :new)
 
@@ -194,26 +174,18 @@ module Dry
         end
 
         # @private
-        def failure
-          @value
-        end
+        def failure = @value
 
         # Apply the first function to value.
         #
         # @api public
-        def result(f, _)
-          f.(@value)
-        end
+        def result(f, _) = f.(@value)
 
         # Returns true
-        def failure?
-          true
-        end
+        def failure? = true
 
         # Returns false
-        def success?
-          false
-        end
+        def success? = false
 
         # If a block is given passes internal value to it and returns the result,
         # otherwise simply returns the first argument.
@@ -243,9 +215,7 @@ module Dry
         #
         # @param args [Array<Object>] arguments will be passed to the underlying `#or` call
         # @return [Result::Success] Wrapped value
-        def or_fmap(...)
-          Success.new(self.or(...))
-        end
+        def or_fmap(...) = Success.new(self.or(...))
 
         # @return [String]
         def to_s
@@ -260,9 +230,7 @@ module Dry
         # Transform to a Success instance
         #
         # @return [Result::Success]
-        def flip
-          Success.new(@value)
-        end
+        def flip = Success.new(@value)
 
         # @see RightBiased::Left#value_or
         def value_or(val = nil)
@@ -287,9 +255,7 @@ module Dry
         # @param _ [#call] Ignored
         # @param g [#call] Function to call
         # @return [Any] Return value of `g`
-        def either(_, g)
-          g.(failure)
-        end
+        def either(_, g) = g.(failure)
 
         # Lifts a block/proc over Failure
         #
@@ -405,9 +371,7 @@ module Dry
         # @param fail [#call] Fallback value
         # @param block [Proc] Fallback block
         # @return [Success<Any>]
-        def to_result(_fail = Unit)
-          Result::Success.new(@value)
-        end
+        def to_result(_fail = Unit) = Result::Success.new(@value)
       end
 
       class None < Maybe
@@ -442,9 +406,7 @@ module Dry
     class Try
       class Value < Try
         # @return [Result::Success]
-        def to_result
-          Dry::Monads::Result::Success.new(@value)
-        end
+        def to_result = ::Dry::Monads::Result::Success.new(@value)
       end
 
       class Error < Try
@@ -460,9 +422,7 @@ module Dry
         # Converts to Result::Success
         #
         # @return [Result::Success]
-        def to_result
-          Result.pure(value!)
-        end
+        def to_result = Result.pure(value!)
       end
 
       class Invalid < Validated

data/lib/dry/monads/right_biased.rb

@@ -21,9 +21,7 @@ module Dry
         # Unwraps the underlying value
         #
         # @return [Object]
-        def value!
-          @value
-        end
+        def value! = @value
 
         # Calls the passed in Proc object with value stored in self
         # and returns the result.
@@ -65,25 +63,19 @@ module Dry
         #
         # @param [Array<Object>] args arguments will be transparently passed through to #bind
         # @return [RightBiased::Right]
-        def tee(...)
-          bind(...).bind { self }
-        end
+        def tee(...) = bind(...).bind { self }
 
         # Abstract method for lifting a block over the monad type.
         # Must be implemented for a right-biased monad.
         #
         # @return [RightBiased::Right]
-        def fmap(*)
-          raise NotImplementedError
-        end
+        def fmap(...) = bind(...)
 
         # Ignores arguments and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Left}.
         #
         # @return [RightBiased::Right]
-        def or(*)
-          self
-        end
+        def or(...) = self
 
         # Ignores arguments and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Left}.
@@ -91,24 +83,18 @@ module Dry
         # @param _alt [RightBiased::Right, RightBiased::Left]
         #
         # @return [RightBiased::Right]
-        def |(_alt)
-          self
-        end
+        def |(_alt) = self
 
         # A lifted version of `#or`. For {RightBiased::Right} acts in the same way as `#or`,
         # that is returns itselt.
         #
         # @return [RightBiased::Right]
-        def or_fmap(*)
-          self
-        end
+        def or_fmap(...) = self
 
         # Returns value. It exists to keep the interface identical to that of RightBiased::Left
         #
         # @return [Object]
-        def value_or(_val = nil)
-          @value
-        end
+        def value_or(_val = nil) = @value
 
         # Applies the stored value to the given argument if the argument has type of Right,
         # otherwise returns the argument.
@@ -145,9 +131,7 @@ module Dry
         #   # => Success(Unit)
         #
         # @return [RightBiased::Right]
-        def discard
-          fmap { Unit }
-        end
+        def discard = fmap { Unit }
 
         # Removes one level of monad structure by joining two values.
         #
@@ -158,9 +142,7 @@ module Dry
         #   Failure(:not_a_number).flatten # => Failure(:not_a_number)
         #
         # @return [RightBiased::Right,RightBiased::Left]
-        def flatten
-          bind(&:itself)
-        end
+        def flatten = bind(&:itself)
 
         # Combines the wrapped value with another monadic value.
         # If both values are right-sided, yields a block and passes a tuple
@@ -252,38 +234,28 @@ module Dry
       module Left
         # @private
         # @return [String] Caller location
-        def self.trace_caller
-          caller_locations(2, 1)[0].to_s
-        end
+        def self.trace_caller = caller_locations(2, 1)[0].to_s
 
         # Raises an error on accessing internal value
-        def value!
-          raise UnwrapError, self
-        end
+        def value! = raise UnwrapError, self
 
         # Ignores the input parameter and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def bind(*)
-          self
-        end
+        def bind(...) = self
 
         # Ignores the input parameter and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def tee(*)
-          self
-        end
+        def tee(...) = self
 
         # Ignores the input parameter and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def fmap(*)
-          self
-        end
+        def fmap(...) = self
 
         # Left-biased #bind version.
         #
@@ -293,18 +265,14 @@ module Dry
         #   Dry::Monads.None.or { Time.now } # => current time
         #
         # @return [Object]
-        def or(*)
-          raise NotImplementedError
-        end
+        def or(...) = raise NotImplementedError
 
         # 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
+        def |(alt) = self.or(alt)
 
         # A lifted version of `#or`. This is basically `#or` + `#fmap`.
         #
@@ -313,9 +281,7 @@ module Dry
         #   Dry::Monads.None.or_fmap { Time.now } # => Some(current time)
         #
         # @return [RightBiased::Left, RightBiased::Right]
-        def or_fmap(*)
-          raise NotImplementedError
-        end
+        def or_fmap(...) = raise NotImplementedError
 
         # Returns the passed value
         #
@@ -332,33 +298,25 @@ module Dry
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def apply(*)
-          self
-        end
+        def apply(...) = self
 
         # Returns self back. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def discard
-          self
-        end
+        def discard = self
 
         # Returns self back. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def flatten
-          self
-        end
+        def flatten = self
 
         # Returns self back. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
         # @return [RightBiased::Left]
-        def and(_)
-          self
-        end
+        def and(_) = self
 
         # Pattern matching
         #

data/lib/dry/monads/task.rb

@@ -27,11 +27,11 @@ module Dry
         #   @param block [Proc] a task to run
         #   @return [Task]
         #
-        def new(promise = nil, &block)
+        def new(promise = nil, &)
           if promise
             super(promise)
           else
-            super(Promise.execute(&block))
+            super(Promise.execute(&))
           end
         end
 
@@ -50,8 +50,8 @@ module Dry
         #   from concurrent-ruby
         #
         # @return [Task]
-        def [](executor, &block)
-          new(Promise.execute(executor: executor, &block))
+        def [](executor, &)
+          new(Promise.execute(executor: executor, &))
         end
 
         # Returns a completed task from the given value
@@ -73,9 +73,7 @@ module Dry
         #
         # @param exc [Exception]
         # @return [Task]
-        def failed(exc)
-          new(Promise.reject(exc))
-        end
+        def failed(exc) = new(Promise.reject(exc))
       end
 
       include ConversionStubs[:to_maybe, :to_result]
@@ -110,9 +108,7 @@ module Dry
       # @param block [Proc]
       # @return [Task]
       # @api public
-      def fmap(&block)
-        self.class.new(promise.then(&block))
-      end
+      def fmap(&) = self.class.new(promise.then(&))
 
       # Composes two tasks to run one after another.
       # A more common name is `then` exists as an alias.
@@ -148,9 +144,7 @@ module Dry
       #
       # @param block [Proc]
       # @return [Task]
-      def or_fmap(&block)
-        self.class.new(promise.rescue(&block))
-      end
+      def or_fmap(&) = self.class.new(promise.rescue(&))
 
       # Rescues the error with a block that returns another task.
       #
@@ -180,9 +174,7 @@ module Dry
       #
       # @param block [Proc]
       # @return [Object]
-      def value_or(&block)
-        promise.rescue(&block).wait.value
-      end
+      def value_or(&) = promise.rescue(&).wait.value
 
       # Blocks the current thread until the task is complete.
       #
@@ -206,21 +198,15 @@ module Dry
       # Whether the computation is complete.
       #
       # @return [Boolean]
-      def complete?
-        promise.complete?
-      end
+      def complete? = promise.complete?
 
       # @return [Class]
-      def monad
-        Task
-      end
+      def monad = Task
 
       # Returns self.
       #
       # @return [Maybe::Some, Maybe::None]
-      def to_monad
-        self
-      end
+      def to_monad = self
 
       # Applies the stored value to the given argument.
       #
@@ -233,17 +219,15 @@ module Dry
       #
       # @param val [Task]
       # @return [Task]
-      def apply(val = Undefined, &block)
-        arg = Undefined.default(val, &block)
+      def apply(val = Undefined, &)
+        arg = Undefined.default(val, &)
         bind { |f| arg.fmap { curry(f).(_1) } }
       end
 
       # Maps a successful result to Unit, effectively discards it
       #
       # @return [Task]
-      def discard
-        fmap { Unit }
-      end
+      def discard = fmap { Unit }
 
       private
 
@@ -302,9 +286,7 @@ module Dry
           #
           # @param block [Proc]
           # @return Task
-          def Task(&block)
-            Task.new(&block)
-          end
+          def Task(&) = Task.new(&)
         end
 
         include Constructors

data/lib/dry/monads/try.rb

@@ -73,23 +73,17 @@ module Dry
       end
 
       # Returns true for an instance of a {Try::Value} monad.
-      def value?
-        is_a?(Value)
-      end
+      def value? = is_a?(Value)
       alias_method :success?, :value?
 
       # Returns true for an instance of a {Try::Error} monad.
-      def error?
-        is_a?(Error)
-      end
+      def error? = is_a?(Error)
       alias_method :failure?, :error?
 
       # Returns self.
       #
       # @return [Try::Value, Try::Error]
-      def to_monad
-        self
-      end
+      def to_monad = self
 
       # Represents a result of a successful execution.
       #
@@ -168,9 +162,7 @@ module Dry
         # @param errors [Class] List of Exception subclasses
         #
         # @return [Try::Value]
-        def recover(*_errors)
-          self
-        end
+        def recover(*_errors) = self
       end
 
       # Represents a result of a failed execution.
@@ -186,13 +178,11 @@ module Dry
         def initialize(exception)
           super()
 
-          @exception = exception
+          @exception = @value = exception
         end
 
         # @return [String]
-        def to_s
-          "Try::Error(#{exception.class}: #{exception.message})"
-        end
+        def to_s = "Try::Error(#{exception.class}: #{exception.message})"
         alias_method :inspect, :to_s
 
         # If a block is given passes internal value to it and returns the result,
@@ -215,9 +205,7 @@ module Dry
 
         # @param other [Try]
         # @return [Boolean]
-        def ===(other)
-          Error === other && exception === other.exception
-        end
+        def ===(other) = Error === other && exception === other.exception
 
         # Acts in a similar way to `rescue`. It checks if
         # {exception} is one of {errors} and yields the block if so.

data/lib/dry/monads/unit.rb

@@ -19,18 +19,9 @@ module Dry
     #   => Some(Unit)
     #
     Unit = ::Object.new.tap do |unit|
-      def unit.to_s
-        "Unit"
-      end
-
-      def unit.inspect
-        "Unit"
-      end
-
-      def unit.deconstruct
-        EMPTY_ARRAY
-      end
-
+      def unit.to_s = "Unit"
+      def unit.inspect = "Unit"
+      def unit.deconstruct = EMPTY_ARRAY
       unit.freeze
     end
   end