fear 2.0.1 → 3.1.0

data/Rakefile

@@ -2,15 +2,30 @@
 
 require "bundler/gem_tasks"
 require "benchmark/ips"
+require "dry/monads"
 require_relative "lib/fear"
 
+include Dry::Monads[:maybe]
+
+class Operation
+  include Dry::Monads::Do.for(:call)
+
+  def call
+    m1 = Some(1)
+    m2 = Some(2)
+
+    one = yield m1
+    two = yield m2
+
+    Some(one + two)
+  end
+end
+
 namespace :perf do
   # Contains benchmarking against Dry-rb
   namespace :dry do
     task :some_fmap_vs_fear_some_map do
-      require "dry/monads/maybe"
-
-      dry = Dry::Monads::Some.new(42)
+      dry = Some(42)
       fear = Fear.some(42)
 
       Benchmark.ips do |x|
@@ -23,28 +38,12 @@ namespace :perf do
     end
 
     task :do_vs_fear_for do
-      require "dry/monads/maybe"
       require "dry/monads/do"
 
-      class Operation
-        include Dry::Monads::Maybe::Mixin
-        include Dry::Monads::Do.for(:call)
-
-        def call
-          m1 = Some(1)
-          m2 = Some(2)
-
-          one = yield m1
-          two = yield m2
-
-          Some(one + two)
-        end
-      end
-
       op = Operation.new
 
       Benchmark.ips do |x|
-        x.report("Dry") { op.() }
+        x.report("Dry") { op.call }
 
         x.report("Fear") do |_n|
           Fear.for(Fear.some(1), Fear.some(2)) do |one, two|
@@ -59,40 +58,21 @@ namespace :perf do
 
   # Contains internal benchmarking to if optimization works
   namespace :fear do
-    task :fear_pattern_extracting_with_vs_without_cache do
-      some = Fear.some([:err, "not found"])
-
-      class WOCache < Fear::Extractor::Pattern
-        def initialize(pattern)
-          @matcher = compile_pattern_without_cache(pattern)
-        end
-      end
-      pattern = "Fear::Some([:err, code])"
-
-      Benchmark.ips do |x|
-        x.report("With cache") do |_n|
-          Fear::Extractor::Pattern.new(pattern).extracted_arguments(some)
-        end
-
-        x.report("Without cache") do |_n|
-          WOCache.new(pattern).extracted_arguments(some)
-        end
-
-        x.compare!
-      end
-    end
-
     namespace :guard do
       task :and1_vs_new do
-        condition = Integer
+        iterations = 1_000
 
         Benchmark.ips do |x|
           x.report("Guard.new") do |n|
-            Fear::PartialFunction::Guard.new(condition) === n
+            iterations.times do
+              Fear::PartialFunction::Guard.new(Integer) === n
+            end
           end
 
           x.report("Guard.and1") do |n|
-            Fear::PartialFunction::Guard.and1(condition) === n
+            iterations.times do
+              Fear::PartialFunction::Guard.and1(Integer) === n
+            end
           end
 
           x.compare!
@@ -100,6 +80,7 @@ namespace :perf do
       end
 
       task :and2_vs_and do
+        iterations = 1_000
         first = Integer
         second = ->(x) { x > 2 }
 
@@ -108,11 +89,11 @@ namespace :perf do
 
         Benchmark.ips do |x|
           x.report("and2") do |n|
-            and2 === n
+            iterations.times { and2 === n }
           end
 
           x.report("Guard#and") do |n|
-            and_and === n
+            iterations.times { and_and === n }
           end
 
           x.compare!
@@ -120,6 +101,7 @@ namespace :perf do
       end
 
       task :and3_vs_and_and do
+        iterations = 1_000
         first = Integer
         second = ->(x) { x > 2 }
         third = ->(x) { x < 10 }
@@ -132,11 +114,11 @@ namespace :perf do
 
         Benchmark.ips do |x|
           x.report("Guard.and3") do |n|
-            and3 === n
+            iterations.times { and3 === n }
           end
 
           x.report("Guard#and") do |n|
-            and_and_and === n
+            iterations.times { and_and_and === n }
           end
 
           x.compare!
@@ -159,22 +141,23 @@ namespace :perf do
         end
 
         x.report("execution") do
-          matcher.(42)
+          matcher.call(42)
         end
 
         x.compare!
       end
     end
-  end
-
-  namespace :pattern_matching do
-    require "qo"
-    require "dry/matcher"
 
     task :option_match_vs_native_pattern_match do
       some = Fear.some(42)
 
       Benchmark.ips do |x|
+        matcher = Fear::Option.matcher do |m|
+          m.some(41, &:itself)
+          m.some(42, &:itself)
+          m.some(45, &:itself)
+        end
+
         x.report("case ... in ...") do
           case some
           in Fear::Some(41 => x)
@@ -186,7 +169,7 @@ namespace :perf do
           end
         end
 
-        x.report("Option.match") do
+        x.report("Option#match") do
           some.match do |m|
             m.some(41, &:itself)
             m.some(42, &:itself)
@@ -194,39 +177,31 @@ namespace :perf do
           end
         end
 
+        x.report("Option#matcher") do
+          matcher.call(some)
+        end
+
         x.compare!
       end
     end
+  end
 
-    task :dry_vs_qo_vs_fear_try do
-      module ExhaustivePatternMatch
-        def initialize(*)
-          super
-          @default ||= self.else { raise Fear::MatchError }
-        end
-      end
-
-      SuccessBranch = Qo.create_branch(name: "success", precondition: Fear::Success, extractor: :get)
-      FailureBranch = Qo.create_branch(name: "failure", precondition: Fear::Failure, extractor: :exception)
-
-      PatternMatch = Qo.create_pattern_match(
-        branches: [SuccessBranch, FailureBranch],
-      ).prepend(ExhaustivePatternMatch)
-
-      Fear::Success.include(PatternMatch.mixin(as: :qo_match))
+  namespace :pattern_matching do
+    require "dry/matcher"
 
+    task :dry_vs_fear_try do
       success_case = Dry::Matcher::Case.new(
         match: ->(try, *pattern) {
           try.is_a?(Fear::Success) && pattern.all? { |p| p === try.get }
         },
-        resolve: ->(try) { try.get },
+        resolve: ->(try) { try.get }
       )
 
       failure_case = Dry::Matcher::Case.new(
         match: ->(try, *pattern) {
           try.is_a?(Fear::Failure) && pattern.all? { |p| p === try.exception }
         },
-        resolve: ->(value) { value.exception },
+        resolve: ->(value) { value.exception }
       )
 
       # Build the matcher
@@ -235,14 +210,6 @@ namespace :perf do
       success = Fear::Success.new(4)
 
       Benchmark.ips do |x|
-        x.report("Qo") do
-          success.qo_match do |m|
-            m.failure(&:itself)
-            m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
-            m.success { "else" }
-          end
-        end
-
         x.report("Fear") do
           success.match do |m|
             m.failure(&:itself)
@@ -252,7 +219,7 @@ namespace :perf do
         end
 
         x.report("Dr::Matcher") do
-          matcher.(success) do |m|
+          matcher.call(success) do |m|
             m.failure(&:itself)
             m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
             m.success { "else" }
@@ -263,82 +230,28 @@ namespace :perf do
       end
     end
 
-    task :qo_vs_fear_try_execution do
-      module ExhaustivePatternMatch
-        def initialize(*)
-          super
-          @default ||= self.else { raise Fear::MatchError }
-        end
-      end
-
-      SuccessBranch = Qo.create_branch(name: "success", precondition: Fear::Success, extractor: :get)
-      FailureBranch = Qo.create_branch(name: "failure", precondition: Fear::Failure, extractor: :exception)
-
-      QoPatternMatch = Qo.create_pattern_match(
-        branches: [SuccessBranch, FailureBranch],
-      ).prepend(ExhaustivePatternMatch)
-
-      Fear::Success.include(QoPatternMatch.mixin(as: :qo_match))
-
-      success = Fear::Success.new(4)
-
-      qo_matcher = QoPatternMatch.new do |m|
-        m.success(1, &:itself)
-        m.success(4, &:itself)
-        m.failure { "failure" }
-      end
-
-      fear_matcher = Fear::TryPatternMatch.new do |m|
-        m.success(1, &:itself)
-        m.success(4, &:itself)
-        m.failure { "failure" }
-      end
-
-      Benchmark.ips do |x|
-        x.report("Qo") do
-          qo_matcher.(success)
-        end
-
-        x.report("Fear") do
-          fear_matcher.(success)
-        end
-
-        x.compare!
-      end
-    end
-
     task :factorial do
       factorial_proc = proc do |n|
         if n <= 1
           1
         else
-          n * factorial_proc.(n - 1)
+          n * factorial_proc.call(n - 1)
         end
       end
 
       factorial_pm = Fear.matcher do |m|
         m.case(1, &:itself)
         m.case(0, &:itself)
-        m.else { |n| n * factorial_pm.(n - 1) }
-      end
-
-      factorial_qo = Qo.match do |m|
-        m.when(1, &:itself)
-        m.when(0, &:itself)
-        m.else { |n| n * factorial_qo.(n - 1) }
+        m.else { |n| n * factorial_pm.call(n - 1) }
       end
 
       Benchmark.ips do |x|
         x.report("Proc") do
-          factorial_proc.(100)
+          factorial_proc.call(100)
         end
 
         x.report("Fear") do
-          factorial_pm.(100)
-        end
-
-        x.report("Qo") do
-          factorial_qo.(100)
+          factorial_pm.call(100)
         end
 
         x.compare!

data/benchmarks/dry_do_vs_fear_for.txt

@@ -1,11 +1,12 @@
 > bundle exec rake perf:dry:do_vs_fear_for
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-                 Dry    31.375k i/100ms
-                Fear    24.131k i/100ms
+                 Dry    50.838k i/100ms
+                Fear    53.687T i/100ms
 Calculating -------------------------------------
-                 Dry    360.990k (± 2.7%) i/s -      1.820M in   5.045364s
-                Fear      7.212B (±27.2%) i/s -     27.210B in   4.656760s
+                 Dry    505.586k (± 1.3%) i/s -      2.542M in   5.028546s
+                Fear 38414118363278401536.000 (±35.1%) i/s - 129350402624716800000.000 in   4.237227s
 
 Comparison:
-                Fear: 7212177713.5 i/s
-                 Dry:   360989.8 i/s - 19978.90x  slower
+                Fear: 38414118363278401536.0 i/s
+                 Dry:   505586.3 i/s - 75979343079241.66x  slower

data/benchmarks/dry_some_fmap_vs_fear_some_map.txt

@@ -1,11 +1,12 @@
 > bundle exec rake perf:dry:some_fmap_vs_fear_some_map
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-                 Dry    68.154k i/100ms
-                Fear   151.093k i/100ms
+                 Dry   156.108k i/100ms
+                Fear   398.884k i/100ms
 Calculating -------------------------------------
-                 Dry    884.315k (± 4.1%) i/s -      4.430M in   5.018931s
-                Fear      2.481M (± 4.1%) i/s -     12.390M in   5.003728s
+                 Dry      1.561M (± 0.2%) i/s -      7.962M in   5.099636s
+                Fear      3.976M (± 0.5%) i/s -     19.944M in   5.016186s
 
 Comparison:
-                Fear:  2480589.0 i/s
-                 Dry:   884315.1 i/s - 2.81x  slower
+                Fear:  3976079.7 i/s
+                 Dry:  1561199.0 i/s - 2.55x  slower

data/benchmarks/factorial.txt

@@ -1,16 +1,14 @@
 # Depends on `n`, for 100!:
 
 > bundle exec rake perf:pattern_matching:factorial
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
 Warming up --------------------------------------
-                Proc     2.395k i/100ms
-                Fear   312.000  i/100ms
-                  Qo   122.000  i/100ms
+                Proc     5.678k i/100ms
+                Fear   859.000 i/100ms
 Calculating -------------------------------------
-                Proc     26.620k (± 2.9%) i/s -    134.120k in   5.042738s
-                Fear      3.219k (± 4.1%) i/s -     16.224k in   5.049215s
-                  Qo      1.250k (± 4.8%) i/s -      6.344k in   5.090745s
+                Proc     56.634k (± 0.2%) i/s -    283.900k in   5.012921s
+                Fear      8.573k (± 0.5%) i/s -     42.950k in   5.009859s
 
 Comparison:
-                Proc:    26620.3 i/s
-                Fear:     3219.4 i/s - 8.27x  slower
-                  Qo:     1249.6 i/s - 21.30x  slower
+                Proc:    56633.8 i/s
+                Fear:     8573.3 i/s - 6.61x  slower

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/examples/pattern_extracting.rb

@@ -13,5 +13,5 @@ matcher = proc do |value|
   end
 end
 
-matcher.(User.new(1, "Jane", true))
-matcher.(User.new(1, "John", false))
+matcher.call(User.new(1, "Jane", true))
+matcher.call(User.new(1, "John", false))

data/examples/pattern_matching_number_in_words.rb

@@ -31,7 +31,7 @@ class ToWords
     60 => "sixty",
     70 => "seventy",
     80 => "eighty",
-    90 => "ninety",
+    90 => "ninety"
   }.freeze
   private_constant :NUMBERS
 
@@ -39,22 +39,22 @@ class ToWords
     NUMBERS.each_pair do |number, in_words|
       m.case(number) { in_words }
     end
-    m.case(->(n) { n < 0 }) { |n| "minus #{CONVERTER.(-n)}" }
-    m.case(->(n) { n < 100 }) { |n| "#{CONVERTER.((n / 10) * 10)}-#{CONVERTER.(n % 10)}" }
-    m.case(->(n) { n < 200 }) { |n| "one hundred #{CONVERTER.(n % 100)}" }
-    m.case(->(n) { n < 1_000 }) { |n| "#{CONVERTER.(n / 100)} hundreds #{CONVERTER.(n % 100)}" }
-    m.case(->(n) { n < 2_000 }) { |n| "one thousand #{CONVERTER.(n % 1000)}" }
-    m.case(->(n) { n < 1_000_000 }) { |n| "#{CONVERTER.(n / 1_000)} thousands #{CONVERTER.(n % 1_000)}" }
+    m.case(->(n) { n < 0 }) { |n| "minus #{CONVERTER.call(-n)}" }
+    m.case(->(n) { n < 100 }) { |n| "#{CONVERTER.call((n / 10) * 10)}-#{CONVERTER.call(n % 10)}" }
+    m.case(->(n) { n < 200 }) { |n| "one hundred #{CONVERTER.call(n % 100)}" }
+    m.case(->(n) { n < 1_000 }) { |n| "#{CONVERTER.call(n / 100)} hundreds #{CONVERTER.call(n % 100)}" }
+    m.case(->(n) { n < 2_000 }) { |n| "one thousand #{CONVERTER.call(n % 1000)}" }
+    m.case(->(n) { n < 1_000_000 }) { |n| "#{CONVERTER.call(n / 1_000)} thousands #{CONVERTER.call(n % 1_000)}" }
     m.else { |n| raise "#{n} too big " }
   end
   private_constant :CONVERTER
 
   def self.call(number)
-    Fear.case(Integer, &:itself).and_then(CONVERTER).(number)
+    Fear.case(Integer, &:itself).and_then(CONVERTER).call(number)
   end
 end
 
-ToWords.(99) #=> 'ninety-nine'
-ToWords.(133) #=> 'one hundred thirty-three
-ToWords.(777) #=> 'seven hundreds seventy-seven'
-ToWords.(254_555) #=> 'two hundreds fifty-four thousands five hundreds fifty-five'
+ToWords.call(99) #=> 'ninety-nine'
+ToWords.call(133) #=> 'one hundred thirty-three
+ToWords.call(777) #=> 'seven hundreds seventy-seven'
+ToWords.call(254_555) #=> 'two hundreds fifty-four thousands five hundreds fifty-five'

data/fear.gemspec

@@ -8,33 +8,17 @@ 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"
   spec.license = "MIT"
 
   spec.files = `git ls-files -z`.split("\x0")
-  spec.executables = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
-  spec.test_files = spec.files.grep(%r{^spec\/})
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2")
 
-  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