fear 0.9.0 → 1.2.0

data/Rakefile

@@ -1 +1,369 @@
-require 'bundler/gem_tasks'
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "benchmark/ips"
+require_relative "lib/fear"
+
+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)
+      fear = Fear.some(42)
+
+      Benchmark.ips do |x|
+        x.report("Dry") { dry.fmap(&:itself) }
+
+        x.report("Fear") { fear.map(&:itself) }
+
+        x.compare!
+      end
+    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("Fear") do |_n|
+          Fear.for(Fear.some(1), Fear.some(2)) do |one, two|
+            one + two
+          end
+        end
+
+        x.compare!
+      end
+    end
+  end
+
+  # 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
+
+        Benchmark.ips do |x|
+          x.report("Guard.new") do |n|
+            Fear::PartialFunction::Guard.new(condition) === n
+          end
+
+          x.report("Guard.and1") do |n|
+            Fear::PartialFunction::Guard.and1(condition) === n
+          end
+
+          x.compare!
+        end
+      end
+
+      task :and2_vs_and do
+        first = Integer
+        second = ->(x) { x > 2 }
+
+        and2 = Fear::PartialFunction::Guard.and2(first, second)
+        and_and = Fear::PartialFunction::Guard.new(first).and(Fear::PartialFunction::Guard.new(second))
+
+        Benchmark.ips do |x|
+          x.report("and2") do |n|
+            and2 === n
+          end
+
+          x.report("Guard#and") do |n|
+            and_and === n
+          end
+
+          x.compare!
+        end
+      end
+
+      task :and3_vs_and_and do
+        first = Integer
+        second = ->(x) { x > 2 }
+        third = ->(x) { x < 10 }
+
+        and3 = Fear::PartialFunction::Guard.and3(first, second, third)
+
+        and_and_and = Fear::PartialFunction::Guard.new(first)
+          .and(Fear::PartialFunction::Guard.new(second))
+          .and(Fear::PartialFunction::Guard.new(third))
+
+        Benchmark.ips do |x|
+          x.report("Guard.and3") do |n|
+            and3 === n
+          end
+
+          x.report("Guard#and") do |n|
+            and_and_and === n
+          end
+
+          x.compare!
+        end
+      end
+    end
+
+    task :pattern_matching_construction_vs_execution do
+      matcher = Fear::PatternMatch.new do |m|
+        m.case(Integer) { |x| x * 2 }
+        m.case(String) { |x| x.to_i(10) * 2 }
+      end
+
+      Benchmark.ips do |x|
+        x.report("construction") do
+          Fear::PatternMatch.new do |m|
+            m.case(Integer) { |y| y * 2 }
+            m.case(String) { |y| y.to_i(10) * 2 }
+          end
+        end
+
+        x.report("execution") do
+          matcher.(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|
+        x.report("case ... in ...") do
+          case some
+          in Fear::Some(41 => x)
+            x
+          in Fear::Some(42 => x)
+            x
+          in Fear::Some(43 => x)
+            x
+          end
+        end
+
+        x.report("Option.match") do
+          some.match do |m|
+            m.some(41, &:itself)
+            m.some(42, &:itself)
+            m.some(45, &:itself)
+          end
+        end
+
+        x.compare!
+      end
+    end
+
+    task :qo_vs_fear_pattern_extraction do
+      User = Struct.new(:id, :name)
+      user = User.new(42, "Jane")
+
+      Benchmark.ips do |x|
+        x.report("Qo") do
+          Qo.case(user, destructure: true) do |m|
+            m.when(User) { |id, name| [id, name] }
+          end
+        end
+
+        x.report("Fear") do
+          Fear.match(user) do |m|
+            m.xcase("User(id, name)") { |id:, name:| [id, name] }
+          end
+        end
+
+        x.compare!
+      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))
+
+      success_case = Dry::Matcher::Case.new(
+        match: ->(try, *pattern) {
+          try.is_a?(Fear::Success) && pattern.all? { |p| p === 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 },
+      )
+
+      # Build the matcher
+      matcher = Dry::Matcher.new(success: success_case, failure: failure_case)
+
+      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)
+            m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
+            m.success { "else" }
+          end
+        end
+
+        x.report("Dr::Matcher") do
+          matcher.(success) do |m|
+            m.failure(&:itself)
+            m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
+            m.success { "else" }
+          end
+        end
+
+        x.compare!
+      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)
+        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) }
+      end
+
+      Benchmark.ips do |x|
+        x.report("Proc") do
+          factorial_proc.(100)
+        end
+
+        x.report("Fear") do
+          factorial_pm.(100)
+        end
+
+        x.report("Qo") do
+          factorial_qo.(100)
+        end
+
+        x.compare!
+      end
+    end
+  end
+end

data/benchmarks/README.md

@@ -0,0 +1 @@
+See Rakefile

data/benchmarks/dry_do_vs_fear_for.txt

@@ -0,0 +1,11 @@
+> bundle exec rake perf:dry:do_vs_fear_for
+Warming up --------------------------------------
+                 Dry    31.375k i/100ms
+                Fear    24.131k 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
+
+Comparison:
+                Fear: 7212177713.5 i/s
+                 Dry:   360989.8 i/s - 19978.90x  slower

data/benchmarks/dry_some_fmap_vs_fear_some_map.txt

@@ -0,0 +1,11 @@
+> bundle exec rake perf:dry:some_fmap_vs_fear_some_map
+Warming up --------------------------------------
+                 Dry    68.154k i/100ms
+                Fear   151.093k 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
+
+Comparison:
+                Fear:  2480589.0 i/s
+                 Dry:   884315.1 i/s - 2.81x  slower

data/benchmarks/factorial.txt

@@ -0,0 +1,16 @@
+# Depends on `n`, for 100!:
+
+> bundle exec rake perf:pattern_matching:factorial
+Warming up --------------------------------------
+                Proc     2.395k i/100ms
+                Fear   312.000  i/100ms
+                  Qo   122.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
+
+Comparison:
+                Proc:    26620.3 i/s
+                Fear:     3219.4 i/s - 8.27x  slower
+                  Qo:     1249.6 i/s - 21.30x  slower

data/benchmarks/fear_gaurd_and1_vs_new.txt

@@ -0,0 +1,13 @@
+# It verifies that optimization for Partial Functions with only one guard actually works.
+
+> bundle exec rake perf:fear:guard:and1_vs_new
+Warming up --------------------------------------
+           Guard.new   173.019k i/100ms
+          Guard.and1   268.379k i/100ms
+Calculating -------------------------------------
+           Guard.new    171.291B (± 8.4%) i/s -    561.437B
+          Guard.and1    266.882B (± 5.9%) i/s -    751.316B
+
+Comparison:
+          Guard.and1: 266881817299.6 i/s
+           Guard.new: 171291386467.1 i/s - 1.56x  slower

data/benchmarks/fear_gaurd_and2_vs_and.txt

@@ -0,0 +1,13 @@
+# It verifies that optimization for Partial Functions with two guards actually works.
+
+> bundle exec rake perf:fear:guard:and2_vs_guard_and_guard
+Warming up --------------------------------------
+                and2   224.836k i/100ms
+           Guard#and   211.833k i/100ms
+Calculating -------------------------------------
+                and2    224.457B (± 3.8%) i/s -    651.564B
+           Guard#and    211.486B (± 3.7%) i/s -    667.936B
+
+Comparison:
+                and2: 224457051906.8 i/s
+           Guard#and: 211485786834.4 i/s - same-ish: difference falls within error

data/benchmarks/fear_gaurd_and3_vs_and_and.txt

@@ -0,0 +1,13 @@
+# It verifies that optimization for Partial Functions with three guards actually works.
+
+> bundle exec rake perf:fear:guard:and3_vs_and_and
+Warming up --------------------------------------
+          Guard.and3   236.318k i/100ms
+           Guard#and   170.369k i/100ms
+Calculating -------------------------------------
+          Guard.and3    235.992B (± 3.4%) i/s -    791.166B
+           Guard#and    169.998B (± 4.0%) i/s -    640.637B
+
+Comparison:
+          Guard.and3: 235992292688.6 i/s
+           Guard#and: 169997755111.1 i/s - 1.39x  slower