fear 2.0.1 → 3.0.0

data/benchmarks/fear_gaurd_and1_vs_new.txt

@@ -1,13 +1,14 @@
 # It verifies that optimization for Partial Functions with only one guard actually works.
 
 > bundle exec rake perf:fear:guard:and1_vs_new
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-           Guard.new   173.019k i/100ms
-          Guard.and1   268.379k i/100ms
+           Guard.new   571.139B i/100ms
+          Guard.and1     1.884T i/100ms
 Calculating -------------------------------------
-           Guard.new    171.291B (± 8.4%) i/s -    561.437B
-          Guard.and1    266.882B (± 5.9%) i/s -    751.316B
+           Guard.new      2.927Q (±10.3%) i/s -     14.393Q in   4.993407s
+          Guard.and1     32.583Q (± 2.2%) i/s -    162.090Q in   4.977493s
 
 Comparison:
-          Guard.and1: 266881817299.6 i/s
-           Guard.new: 171291386467.1 i/s - 1.56x  slower
+          Guard.and1: 32583184202679384.0 i/s
+           Guard.new: 2927179441726049.0 i/s - 11.13x  slower

data/benchmarks/fear_gaurd_and2_vs_and.txt

@@ -1,13 +1,14 @@
 # It verifies that optimization for Partial Functions with two guards actually works.
 
-> bundle exec rake perf:fear:guard:and2_vs_guard_and_guard
+> bundle exec rake perf:fear:guard:and2_vs_and
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-                and2   224.836k i/100ms
-           Guard#and   211.833k i/100ms
+                and2   807.325B i/100ms
+           Guard#and   692.737B i/100ms
 Calculating -------------------------------------
-                and2    224.457B (± 3.8%) i/s -    651.564B
-           Guard#and    211.486B (± 3.7%) i/s -    667.936B
+                and2      6.011Q (± 2.4%) i/s -     29.972Q in   4.989608s
+           Guard#and      4.443Q (± 2.1%) i/s -     22.168Q in   4.991463s
 
 Comparison:
-                and2: 224457051906.8 i/s
-           Guard#and: 211485786834.4 i/s - same-ish: difference falls within error
+                and2: 6011198087717350.0 i/s
+           Guard#and: 4443444774459918.5 i/s - 1.35x  slower

data/benchmarks/fear_gaurd_and3_vs_and_and.txt

@@ -1,13 +1,14 @@
 # It verifies that optimization for Partial Functions with three guards actually works.
 
 > bundle exec rake perf:fear:guard:and3_vs_and_and
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-          Guard.and3   236.318k i/100ms
-           Guard#and   170.369k i/100ms
+          Guard.and3   580.401B i/100ms
+           Guard#and   350.896B i/100ms
 Calculating -------------------------------------
-          Guard.and3    235.992B (± 3.4%) i/s -    791.166B
-           Guard#and    169.998B (± 4.0%) i/s -    640.637B
+          Guard.and3      3.152Q (± 1.3%) i/s -     15.736Q in   4.993183s
+           Guard#and      1.132Q (± 1.7%) i/s -      5.653Q in   4.996181s
 
 Comparison:
-          Guard.and3: 235992292688.6 i/s
-           Guard#and: 169997755111.1 i/s - 1.39x  slower
+          Guard.and3: 3152131160662449.0 i/s
+           Guard#and: 1131877273526757.5 i/s - 2.78x  slower

data/benchmarks/fear_pattern_matching_construction_vs_execution.txt

@@ -1,13 +1,14 @@
 # So, it's better to avoid building pattern match in runtime
 
 > bundle exec rake perf:fear:pattern_matching_construction_vs_execution
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-        construction    24.425k i/100ms
-           execution    80.516k i/100ms
+        construction    53.068k i/100ms
+           execution   280.541k i/100ms
 Calculating -------------------------------------
-        construction    267.887k (± 4.9%) i/s -      1.343M in   5.029005s
-           execution      1.085M (± 2.6%) i/s -      5.475M in   5.049775s
+        construction    537.049k (± 0.2%) i/s -      2.706M in   5.039544s
+           execution      2.799M (± 0.4%) i/s -     14.027M in   5.011175s
 
 Comparison:
-           execution:  1084968.2 i/s
-        construction:   267886.6 i/s - 4.05x  slower
+           execution:  2799195.6 i/s
+        construction:   537049.0 i/s - 5.21x  slower

data/benchmarks/pattern_matching_dry_vs_qo_vs_fear_try.txt

@@ -1,14 +1,12 @@
-> bundle exec rake perf:pattern_matching:dry_vs_qo_vs_fear_try
+> bundle exec rake perf:pattern_matching:dry_vs_fear_try
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-                  Qo     2.958k i/100ms
-                Fear     7.127k i/100ms
-         Dr::Matcher    13.079k i/100ms
+                Fear    18.527k i/100ms
+         Dr::Matcher    40.145k i/100ms
 Calculating -------------------------------------
-                  Qo     38.872k (± 3.1%) i/s -    195.228k in   5.027249s
-                Fear     88.756k (± 3.7%) i/s -    449.001k in   5.066471s
-         Dr::Matcher    166.700k (± 3.0%) i/s -    837.056k in   5.026408s
+                Fear    187.617k (± 0.4%) i/s -    944.877k in   5.036258s
+         Dr::Matcher    395.181k (± 1.9%) i/s -      2.007M in   5.081136s
 
 Comparison:
-         Dr::Matcher:   166699.7 i/s
-                Fear:    88755.7 i/s - 1.88x  slower
-                  Qo:    38871.9 i/s - 4.29x  slower
+         Dr::Matcher:   395181.1 i/s
+                Fear:   187617.3 i/s - 2.11x  slower

data/fear.gemspec

@@ -8,8 +8,8 @@ require "fear/version"
 Gem::Specification.new do |spec|
   spec.name = "fear"
   spec.version = Fear::VERSION
-  spec.authors = ["Tema Bolshakov"]
-  spec.email = ["abolshakov@spbtv.com"]
+  spec.authors = ["Tëma Bolshakov"]
+  spec.email = ["tema@bolshakov.dev"]
   spec.summary = "%q{Ruby port of some Scala's monads.}"
   spec.description = "Ruby port of some Scala's monads."
   spec.homepage = "https://github.com/bolshakov/fear"
@@ -19,22 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^spec\/})
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.1")
 
-  spec.add_development_dependency "benchmark-ips"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "concurrent-ruby"
-  spec.add_development_dependency "dry-matcher"
-  spec.add_development_dependency "dry-monads"
-  spec.add_development_dependency "qo"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.1"
-  spec.add_development_dependency "rubocop-rspec", "1.34.0"
-  spec.add_development_dependency "rubocop", "1.32.0"
-  spec.add_development_dependency "ruby_coding_standard"
-  spec.add_development_dependency "yard"
-  spec.add_development_dependency "dry-types"
-  spec.add_development_dependency "fear-rspec"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "simplecov-lcov"
+  spec.add_runtime_dependency "zeitwerk"
 end

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 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.(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.(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.(value)
+          Fear.some(either)
+        in Fear::Either
+          Fear.none
+        end
+      end
+      alias 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 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 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|
@@ -280,6 +280,19 @@ module Fear
       [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

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)

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

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

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