fear 2.0.1 → 3.1.0

data/lib/fear/either/left_projection.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Fear
+  module Either
+    # Projects an `Either` into a `Left`.
+    # @see Fear::Either#left
+    #
+    class LeftProjection
+      prepend Fear::RightBiased::Interface
+
+      # @!attribute either
+      #   @return [Fear::Either]
+      attr_reader :either
+      protected :either
+
+      # @param either [Fear::Either]
+      def initialize(either)
+        @either = either
+      end
+
+      # Returns +true+ if +Fear::Left+ has an element that is equal
+      # (as determined by +==+) to +other_value+, +false+ otherwise.
+      # @param [Object]
+      # @return [Boolean]
+      # @example
+      #   Fear.left(17).left.include?(17)           #=> true
+      #   Fear.left(17).left.include?(7)            #=> false
+      #   Fear.right('undefined').left.include?(17) #=> false
+      #
+      def include?(other_value)
+        case either
+        in Fear::Left(x)
+          x == other_value
+        in Fear::Right
+          false
+        end
+      end
+
+      # Returns the value from this +Fear::Left+ or evaluates the given
+      # default argument if this is a +Fear::Right+.
+      #
+      # @overload get_or_else(&default)
+      #   @yieldreturn [Object]
+      #   @return [Object]
+      #   @example
+      #     Fear.right(42).left.get_or_else { 24/2 }         #=> 12
+      #     Fear.left('undefined').left.get_or_else { 24/2 } #=> 'undefined'
+      #
+      # @overload get_or_else(default)
+      #   @return [Object]
+      #   @example
+      #     Fear.right(42).left.get_or_else(12)         #=> 12
+      #     Fear.left('undefined').left.get_or_else(12) #=> 'undefined'
+      def get_or_else(*args)
+        case either
+        in Fear::Left(value)
+          value
+        in Fear::Right
+          args.fetch(0) { yield }
+        end
+      end
+
+      # Performs the given block if this is a +Fear::Left+.
+      #
+      # @yieldparam [Object] value
+      # @yieldreturn [void]
+      # @return [Fear::Either] itself
+      # @example
+      #   Fear.right(17).left.each do |value|
+      #     puts value
+      #   end #=> does nothing
+      #
+      #   Fear.left('undefined').left.each do |value|
+      #     puts value
+      #   end #=> prints "nothing"
+      def each
+        case either
+        in Fear::Left(value)
+          yield(value)
+          either
+        in Fear::Right
+          either
+        end
+      end
+      alias_method :apply, :each
+
+      # Maps the block argument through +Fear::Left+.
+      #
+      # @yieldparam [Object] value
+      # @yieldreturn [Fear::Either]
+      # @example
+      #   Fear.left(42).left.map { _1/2 }   #=> Fear.left(24)
+      #   Fear.right(42).left.map { _1/2 }  #=> Fear.right(42)
+      #
+      def map
+        case either
+        in Fear::Left(value)
+          Fear.left(yield(value))
+        in Fear::Right
+          either
+        end
+      end
+
+      # Returns the given block applied to the value from this +Fear::Left+
+      # or returns this if this is a +Fear::Right+.
+      #
+      # @yieldparam [Object] value
+      # @yieldreturn [Fear::Either]
+      # @return [Fear::Either]
+      #
+      # @example
+      #   Fear.left(12).left.flat_map { Fear.left(_1 * 2) }  #=> Fear.left(24)
+      #   Fear.left(12).left.flat_map { Fear.right(_1 * 2) } #=> Fear.right(24)
+      #   Fear.right(12).left.flat_map { Fear.left(_1 * 2) } #=> Fear.right(12)
+      #
+      def flat_map
+        case either
+        in Fear::Left(value)
+          yield(value)
+        in Fear::Right
+          either
+        end
+      end
+
+      # Returns an +Fear::Some+ containing the +Fear::Left+ value or a +Fear::None+ if
+      # this is a +Fear::Right+.
+      # @return [Fear::Option]
+      # @example
+      #   Fear.left(42).left.to_option   #=> Fear.some(42)
+      #   Fear.right(42).left.to_option  #=> Fear.none
+      #
+      def to_option
+        case either
+        in Fear::Left(value)
+          Fear.some(value)
+        in Fear::Right
+          Fear.none
+        end
+      end
+
+      # Returns an array containing the +Fear::Left+ value or an empty array if
+      # this is a +Fear::Right+.
+      #
+      # @return [Array]
+      # @example
+      #   Fear.left(42).left.to_a   #=> [42]
+      #   Fear.right(42).left.to_a  #=> []
+      #
+      def to_a
+        case either
+        in Fear::Left(value)
+          [value]
+        in Fear::Right
+          []
+        end
+      end
+
+      # Returns +false+ if +Fear::Right+ or returns the result of the
+      # application of the given predicate to the +Fear::Light+ value.
+      #
+      # @yieldparam [Object] value
+      # @yieldreturn [Boolean]
+      # @return [Boolean]
+      # @example
+      #   Fear.left(12).left.any? { |v| v > 10 }  #=> true
+      #   Fear.left(7).left.any? { |v| v > 10 }   #=> false
+      #   Fear.right(12).left.any? { |v| v > 10 } #=> false
+      #
+      def any?(&predicate)
+        case either
+        in Fear::Left(value)
+          predicate.call(value)
+        in Fear::Right
+          false
+        end
+      end
+
+      # Returns +Fear::Right+ of value if the given predicate
+      # does not hold for the left value, otherwise, returns +Fear::Left+.
+      #
+      # @yieldparam value [Object]
+      # @yieldreturn [Boolean]
+      # @return [Fear::Either]
+      # @example
+      #   Fear.left(12).left.select(&:even?)   #=> Fear.left(12)
+      #   Fear.left(7).left.select(&:even?)    #=> Fear.right(7)
+      #   Fear.right(12).left.select(&:even?)  #=> Fear.right(12)
+      #   Fear.right(7).left.select(&:even?)   #=> Fear.right(7)
+      #
+      def select(&predicate)
+        case either
+        in Fear::Right
+          either
+        in Fear::Left(value) if predicate.call(value)
+          either
+        in Fear::Left
+          either.swap
+        end
+      end
+
+      # Returns +Fear::None+ if this is a +Fear::Right+ or if the given predicate
+      # does not hold for the left value, otherwise, returns a +Fear::Left+.
+      #
+      # @yieldparam value [Object]
+      # @yieldreturn [Boolean]
+      # @return [Fear::Option<Fear::Either>]
+      # @example
+      #   Fear.left(12).left.find(&:even?) #=> #<Fear::Some value=#<Fear::Left value=12>>
+      #   Fear.left(7).left.find(&:even?)  #=> #<Fear::None>
+      #   Fear.right(12).left.find(&:even) #=> #<Fear::None>
+      #
+      def find(&predicate)
+        case either
+        in Fear::Left(value) if predicate.call(value)
+          Fear.some(either)
+        in Fear::Either
+          Fear.none
+        end
+      end
+      alias_method :detect, :find
+
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(self.class) && other.either == either
+      end
+
+      private def left_class
+        Fear::Right
+      end
+
+      private def right_class
+        Fear::Left
+      end
+    end
+  end
+end

data/lib/fear/either/pattern_match.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Fear
+  module Either
+    # Either pattern matcher
+    #
+    # @example
+    #   pattern_match =
+    #     EitherPatternMatch.new
+    #       .right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+    #       .right(String) { |x| x.to_i * 2 }
+    #       .left(String) { :err }
+    #       .else { 'error '}
+    #
+    #   pattern_match.call(42) => 'NaN'
+    #
+    #  @example the same matcher may be defined using block syntax
+    #    EitherPatternMatch.new do |m|
+    #      m.right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+    #      m.right(String) { |x| x.to_i * 2 }
+    #      m.left(String) { :err }
+    #      m.else { 'error '}
+    #    end
+    #
+    # @note it has two optimized subclasses +Fear::Left::PatternMatch+ and +Fear::Right::PatternMatch+
+    # @api private
+    class PatternMatch < Fear::PatternMatch
+      # Match against +Fear::Right+
+      #
+      # @param conditions [<#==>]
+      # @return [Fear::Either::PatternMatch]
+      def right(*conditions, &effect)
+        branch = Fear.case(Fear::Right, &:right_value).and_then(Fear.case(*conditions, &effect))
+        or_else(branch)
+      end
+      alias_method :success, :right
+
+      # Match against +Fear::Left+
+      #
+      # @param conditions [<#==>]
+      # @return [Fear::Either::PatternMatch]
+      def left(*conditions, &effect)
+        branch = Fear.case(Fear::Left, &:left_value).and_then(Fear.case(*conditions, &effect))
+        or_else(branch)
+      end
+      alias_method :failure, :left
+    end
+  end
+end

data/lib/fear/either.rb

@@ -116,9 +116,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Boolean]
   #   @example
-  #     Fear.right(12).any?( |v| v > 10)         #=> true
-  #     Fear.right(7).any?( |v| v > 10)          #=> false
-  #     Fear.left('undefined').any?( |v| v > 10) #=> false
+  #     Fear.right(12).any? { |v| v > 10 }         #=> true
+  #     Fear.right(7).any? { |v| v > 10 }          #=> false
+  #     Fear.left('undefined').any? { |v| v > 10 } #=> false
   #
   # -----
   #
@@ -177,7 +177,7 @@ module Fear
   #
   # @!method swap
   #   If this is a +Left+, then return the left value in +Right+ or vice versa.
-  #   @return [Either]
+  #   @return [Fear::Either]
   #   @example
   #     Fear.left('left').swap   #=> Fear.right('left')
   #     Fear.right('right').swap #=> Fear.left('left')
@@ -226,7 +226,7 @@ module Fear
   #
   # @!method match(&matcher)
   #   Pattern match against this +Either+
-  #   @yield matcher [Fear::EitherPatternMatch]
+  #   @yield matcher [Fear::Either::PatternMatch]
   #   @example
   #     either.match do |m|
   #       m.right(Integer) do |x|
@@ -273,13 +273,26 @@ module Fear
     end
 
     # @return [String]
-    alias to_s inspect
+    alias_method :to_s, :inspect
 
     # @return [<any>]
     def deconstruct
       [value]
     end
 
+    # Projects this +Fear::Either+ as a +Fear::Left+.
+    # This allows performing right-biased operation of the left
+    # side of the +Fear::Either+.
+    #
+    # @example
+    #   Fear.left(42).left.map(&:succ)  #=> Fear.left(43)
+    #   Fear.right(42).left.map(&:succ) #=> Fear.left(42)
+    #
+    # @return [Fear::LeftProjection]
+    def left
+      LeftProjection.new(self)
+    end
+
     class << self
       # Build pattern matcher to be used later, despite off
       # +Either#match+ method, id doesn't apply matcher immanently,
@@ -296,10 +309,10 @@ module Fear
       #     end
       #   matcher.call(Fear.right(42))
       #
-      # @yieldparam [Fear::EitherPatternMatch]
+      # @yieldparam [Fear::Either::PatternMatch]
       # @return [Fear::PartialFunction]
       def matcher(&matcher)
-        EitherPatternMatch.new(&matcher)
+        Either::PatternMatch.new(&matcher)
       end
     end
 
@@ -331,7 +344,3 @@ module Fear
     end
   end
 end
-
-require "fear/either_pattern_match"
-require "fear/left"
-require "fear/right"

data/lib/fear/either_api.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "fear/either"
-
 module Fear
   module EitherApi
-    # @param value [any]
+    # @param value [Object]
     # @return [Fear::Left]
     # @example
     #   Fear.left(42) #=> #<Fear::Left value=42>
@@ -13,7 +11,7 @@ module Fear
       Fear::Left.new(value)
     end
 
-    # @param value [any]
+    # @param value [Object]
     # @return [Fear::Right]
     # @example
     #   Fear.right(42) #=> #<Fear::Right value=42>

data/lib/fear/empty_partial_function.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Fear
-  # Use singleton version of EmptyPartialFunction -- PartialFunction::EMPTY
+  # Use singleton version of EmptyPartialFunction -- PartialFunction::Empty
   # @api private
   class EmptyPartialFunction
     include PartialFunction
@@ -14,8 +14,8 @@ module Fear
       raise MatchError, "partial function not defined at: #{arg}"
     end
 
-    alias === call
-    alias [] call
+    alias_method :===, :call
+    alias_method :[], :call
 
     def call_or_else(arg)
       yield arg

data/lib/fear/failure/pattern_match.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fear
+  class Failure
+    # @api private
+    class PatternMatch < Try::PatternMatch
+      def success(*_conditions)
+        self
+      end
+    end
+
+    private_constant :PatternMatch
+  end
+end

data/lib/fear/failure.rb

@@ -4,7 +4,7 @@ module Fear
   class Failure
     include Try
     include RightBiased::Left
-    include FailurePatternMatch.mixin
+    include PatternMatch.mixin
 
     # @param [StandardError]
     def initialize(exception)
@@ -31,7 +31,7 @@ module Fear
     # @return [Try] of calling block
     def or_else(*args)
       super
-    rescue StandardError => error
+    rescue => error
       Failure.new(error)
     end
 
@@ -52,7 +52,7 @@ module Fear
       Fear.matcher { |m| yield(m) }
         .and_then { |result| result.tap { Utils.assert_type!(result, Success, Failure) } }
         .call_or_else(exception) { self }
-    rescue StandardError => error
+    rescue => error
       Failure.new(error)
     end
 
@@ -63,7 +63,7 @@ module Fear
       Fear.matcher { |m| yield(m) }
         .and_then { |v| Success.new(v) }
         .call_or_else(exception) { self }
-    rescue StandardError => error
+    rescue => error
       Failure.new(error)
     end
 
@@ -95,7 +95,7 @@ module Fear
     end
 
     # @return [String]
-    alias to_s inspect
+    alias_method :to_s, :inspect
 
     # @return [<StandardError>]
     def deconstruct

data/lib/fear/for.rb

@@ -32,7 +32,7 @@ module Fear
 
     private def resolve(monad_or_proc, inner_values)
       if monad_or_proc.respond_to?(:call)
-        monad_or_proc.(*inner_values)
+        monad_or_proc.call(*inner_values)
       else
         monad_or_proc
       end

data/lib/fear/for_api.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fear/for"
-
 module Fear
   module ForApi
     # Syntactic sugar for composition of  multiple monadic operations. It supports two such
@@ -64,7 +62,7 @@ module Fear
     # @return [{#map, #flat_map}]
     #
     def for(*monads, &block)
-      Fear::For.(monads, &block)
+      Fear::For.call(monads, &block)
     end
   end
 end

data/lib/fear/future.rb

@@ -170,7 +170,7 @@ module Fear
     #
     # If the future has already been completed,
     # this will either be applied immediately or be scheduled asynchronously.
-    # @yieldparam [Fear::TryPatternMatch]
+    # @yieldparam [Fear::Try::PatternMatch]
     # @return [self]
     #
     # @example
@@ -221,7 +221,7 @@ module Fear
     # @yieldparam [any] yields with successful feature value
     # @see {#on_complete}
     #
-    alias each on_success
+    alias_method :each, :on_success
 
     # Creates a new future by applying the +success+ function to the successful
     # result of this future, or the +failure+ function to the failed result.
@@ -245,8 +245,8 @@ module Fear
     def transform(success, failure)
       promise = Promise.new(**@options)
       on_complete_match do |m|
-        m.success { |value| promise.success(success.(value)) }
-        m.failure { |error| promise.failure(failure.(error)) }
+        m.success { |value| promise.success(success.call(value)) }
+        m.failure { |error| promise.failure(failure.call(error)) }
       end
       promise.to_future
     end
@@ -293,7 +293,7 @@ module Fear
         m.case(Fear::Failure) { |failure| promise.complete!(failure) }
         m.success do |value|
           yield(value).on_complete { |callback_result| promise.complete!(callback_result) }
-        rescue StandardError => error
+        rescue => error
           promise.failure!(error)
         end
       end
@@ -379,7 +379,7 @@ module Fear
                 else
                   [value, other_value]
                 end
-              end,
+              end
             )
           end
         end

data/lib/fear/future_api.rb

@@ -6,11 +6,6 @@ rescue LoadError
   puts "You must add 'concurrent-ruby' to your Gemfile in order to use Fear::Future"
 end
 
-require "fear/awaitable"
-require "fear/await"
-require "fear/future"
-require "fear/promise"
-
 module Fear
   # rubocop: disable Layout/LineLength
   module FutureApi

data/lib/fear/left/pattern_match.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fear
+  class Left
+    # @api private
+    class PatternMatch < Fear::Either::PatternMatch
+      def right(*)
+        self
+      end
+      alias_method :success, :right
+    end
+
+    private_constant :PatternMatch
+  end
+end

data/lib/fear/left.rb

@@ -4,7 +4,7 @@ module Fear
   class Left
     include Either
     include RightBiased::Left
-    include LeftPatternMatch.mixin
+    include PatternMatch.mixin
 
     # @api private
     def left_value
@@ -15,13 +15,13 @@ module Fear
     def right?
       false
     end
-    alias success? right?
+    alias_method :success?, :right?
 
     # @return [true]
     def left?
       true
     end
-    alias failure? left?
+    alias_method :failure?, :left?
 
     # @return [Either]
     def select_or_else(*)
@@ -46,7 +46,7 @@ module Fear
     # @param reduce_left [Proc]
     # @return [any]
     def reduce(reduce_left, _reduce_right)
-      reduce_left.(value)
+      reduce_left.call(value)
     end
 
     # @return [self]

data/lib/fear/none.rb

@@ -1,94 +1,7 @@
 # frozen_string_literal: true
 
 module Fear
-  # @api private
-  class NoneClass
-    include Option
-    include RightBiased::Left
-    include NonePatternMatch.mixin
-
-    # @raise [NoSuchElementError]
-    def get
-      raise NoSuchElementError
-    end
-
-    # @return [nil]
-    def or_nil
-      nil
-    end
-
-    # @return [true]
-    def empty?
-      true
-    end
-
-    alias :blank? :empty?
-
-    # @return [false]
-    def present?
-      false
-    end
-
-    # @return [None]
-    def select(*)
-      self
-    end
-
-    # @return [None]
-    def reject(*)
-      self
-    end
-
-    # @return [String]
-    def inspect
-      "#<Fear::NoneClass>"
-    end
-
-    # @return [String]
-    alias to_s inspect
-
-    # @param other [Any]
-    # @return [Boolean]
-    def ==(other)
-      other.is_a?(NoneClass)
-    end
-
-    # @param other
-    # @return [Boolean]
-    def ===(other)
-      self == other
-    end
-
-    # @param other [Fear::Option]
-    # @return [Fear::Option]
-    def zip(other)
-      if other.is_a?(Option)
-        Fear.none
-      else
-        raise TypeError, "can't zip with #{other.class}"
-      end
-    end
-
-    # @return [RightBiased::Left]
-    def filter_map
-      self
-    end
-  end
-
-  private_constant(:NoneClass)
-
   # The only instance of NoneClass
-  # @api private
   None = NoneClass.new.freeze
   public_constant :None
-
-  class << NoneClass
-    def new
-      None
-    end
-
-    def inherited(*)
-      raise "you are not allowed to inherit from NoneClass, use Fear::None instead"
-    end
-  end
 end