fear 1.0.0 → 2.0.0

data/Rakefile

@@ -1,28 +1,30 @@
-require 'bundler/gem_tasks'
-require 'benchmark/ips'
-require_relative 'lib/fear'
+# 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'
+      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("Dry") { dry.fmap(&:itself) }
 
-        x.report('Fear') { fear.map(&: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'
+      require "dry/monads/maybe"
+      require "dry/monads/do"
 
       class Operation
         include Dry::Monads::Maybe::Mixin
@@ -42,9 +44,9 @@ namespace :perf do
       op = Operation.new
 
       Benchmark.ips do |x|
-        x.report('Dry') { op.call }
+        x.report("Dry") { op.() }
 
-        x.report('Fear') do |_n|
+        x.report("Fear") do |_n|
           Fear.for(Fear.some(1), Fear.some(2)) do |one, two|
             one + two
           end
@@ -58,21 +60,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'])
+      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])'
+      pattern = "Fear::Some([:err, code])"
 
       Benchmark.ips do |x|
-        x.report('With cache') do |_n|
+        x.report("With cache") do |_n|
           Fear::Extractor::Pattern.new(pattern).extracted_arguments(some)
         end
 
-        x.report('Without cache') do |_n|
+        x.report("Without cache") do |_n|
           WOCache.new(pattern).extracted_arguments(some)
         end
 
@@ -85,11 +87,11 @@ namespace :perf do
         condition = Integer
 
         Benchmark.ips do |x|
-          x.report('Guard.new') do |n|
+          x.report("Guard.new") do |n|
             Fear::PartialFunction::Guard.new(condition) === n
           end
 
-          x.report('Guard.and1') do |n|
+          x.report("Guard.and1") do |n|
             Fear::PartialFunction::Guard.and1(condition) === n
           end
 
@@ -105,11 +107,11 @@ namespace :perf do
         and_and = Fear::PartialFunction::Guard.new(first).and(Fear::PartialFunction::Guard.new(second))
 
         Benchmark.ips do |x|
-          x.report('and2') do |n|
+          x.report("and2") do |n|
             and2 === n
           end
 
-          x.report('Guard#and') do |n|
+          x.report("Guard#and") do |n|
             and_and === n
           end
 
@@ -120,7 +122,7 @@ namespace :perf do
       task :and3_vs_and_and do
         first = Integer
         second = ->(x) { x > 2 }
-        third = ->(x) {  x < 10 }
+        third = ->(x) { x < 10 }
 
         and3 = Fear::PartialFunction::Guard.and3(first, second, third)
 
@@ -129,11 +131,11 @@ namespace :perf do
           .and(Fear::PartialFunction::Guard.new(third))
 
         Benchmark.ips do |x|
-          x.report('Guard.and3') do |n|
+          x.report("Guard.and3") do |n|
             and3 === n
           end
 
-          x.report('Guard#and') do |n|
+          x.report("Guard#and") do |n|
             and_and_and === n
           end
 
@@ -149,15 +151,15 @@ namespace :perf do
       end
 
       Benchmark.ips do |x|
-        x.report('construction') do
+        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.call(42)
+        x.report("execution") do
+          matcher.(42)
         end
 
         x.compare!
@@ -166,23 +168,29 @@ namespace :perf do
   end
 
   namespace :pattern_matching do
-    require 'qo'
-    require 'dry/matcher'
+    require "qo"
+    require "dry/matcher"
 
-    task :qo_vs_fear_pattern_extraction do
-      User = Struct.new(:id, :name)
-      user = User.new(42, 'Jane')
+    task :option_match_vs_native_pattern_match do
+      some = Fear.some(42)
 
       Benchmark.ips do |x|
-        x.report('Qo') do
-          Qo.case(user, destructure: true) do |m|
-            m.when(User) { |id, name| [id, name] }
+        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('Fear') do
-          Fear.match(user) do |m|
-            m.xcase('User(id, name)') { |id:, name:| [id, name] }
+        x.report("Option.match") do
+          some.match do |m|
+            m.some(41, &:itself)
+            m.some(42, &:itself)
+            m.some(45, &:itself)
           end
         end
 
@@ -198,25 +206,24 @@ namespace :perf do
         end
       end
 
-      SuccessBranch = Qo.create_branch(name: 'success', precondition: Fear::Success, extractor: :get)
-      FailureBranch = Qo.create_branch(name: 'failure', precondition: Fear::Failure, extractor: :exception)
+      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],
+        branches: [SuccessBranch, FailureBranch],
       ).prepend(ExhaustivePatternMatch)
 
       Fear::Success.include(PatternMatch.mixin(as: :qo_match))
 
       success_case = Dry::Matcher::Case.new(
-        match: lambda { |try, *pattern|
+        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: lambda { |try, *pattern|
+        match: ->(try, *pattern) {
           try.is_a?(Fear::Failure) && pattern.all? { |p| p === try.exception }
         },
         resolve: ->(value) { value.exception },
@@ -228,27 +235,27 @@ namespace :perf do
       success = Fear::Success.new(4)
 
       Benchmark.ips do |x|
-        x.report('Qo') do
+        x.report("Qo") do
           success.qo_match do |m|
             m.failure(&:itself)
             m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
-            m.success { 'else' }
+            m.success { "else" }
           end
         end
 
-        x.report('Fear') do
+        x.report("Fear") do
           success.match do |m|
             m.failure(&:itself)
             m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
-            m.success { 'else' }
+            m.success { "else" }
           end
         end
 
-        x.report('Dr::Matcher') do
-          matcher.call(success) do |m|
+        x.report("Dr::Matcher") do
+          matcher.(success) do |m|
             m.failure(&:itself)
             m.success(Integer, ->(y) { y % 5 == 0 }, &:itself)
-            m.success { 'else' }
+            m.success { "else" }
           end
         end
 
@@ -264,8 +271,8 @@ namespace :perf do
         end
       end
 
-      SuccessBranch = Qo.create_branch(name: 'success', precondition: Fear::Success, extractor: :get)
-      FailureBranch = Qo.create_branch(name: 'failure', precondition: Fear::Failure, extractor: :exception)
+      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],
@@ -278,22 +285,22 @@ namespace :perf do
       qo_matcher = QoPatternMatch.new do |m|
         m.success(1, &:itself)
         m.success(4, &:itself)
-        m.failure { 'failure' }
+        m.failure { "failure" }
       end
 
       fear_matcher = Fear::TryPatternMatch.new do |m|
         m.success(1, &:itself)
         m.success(4, &:itself)
-        m.failure { 'failure' }
+        m.failure { "failure" }
       end
 
       Benchmark.ips do |x|
-        x.report('Qo') do
-          qo_matcher.call(success)
+        x.report("Qo") do
+          qo_matcher.(success)
         end
 
-        x.report('Fear') do
-          fear_matcher.call(success)
+        x.report("Fear") do
+          fear_matcher.(success)
         end
 
         x.compare!
@@ -305,33 +312,33 @@ namespace :perf do
         if n <= 1
           1
         else
-          n * factorial_proc.call(n - 1)
+          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.call(n - 1) }
+        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.call(n - 1) }
+        m.else { |n| n * factorial_qo.(n - 1) }
       end
 
       Benchmark.ips do |x|
-        x.report('Proc') do
-          factorial_proc.call(100)
+        x.report("Proc") do
+          factorial_proc.(100)
         end
 
-        x.report('Fear') do
-          factorial_pm.call(100)
+        x.report("Fear") do
+          factorial_pm.(100)
         end
 
-        x.report('Qo') do
-          factorial_qo.call(100)
+        x.report("Qo") do
+          factorial_qo.(100)
         end
 
         x.compare!

data/examples/pattern_extracting.rb

@@ -1,15 +1,17 @@
-require 'fear'
+# frozen_string_literal: true
+
+require "fear"
 
 User = Struct.new(:id, :name, :admin)
 
-matcher = Fear.matcher do |m|
-  m.xcase('User(_, name, true)') do |name:|
+matcher = proc do |value|
+  case value
+  in User(admin: true, name:)
     puts "Hi #{name}, you are welcome"
-  end
-  m.xcase('User(_, _, false)') do
-    puts 'Only admins allowed here'
+  in User(admin: false)
+    puts "Only admins are allowed here"
   end
 end
 
-matcher.call User.new(1, 'Jane', true)
-matcher.call User.new(1, 'John', false)
+matcher.(User.new(1, "Jane", true))
+matcher.(User.new(1, "John", false))

data/examples/pattern_matching_binary_tree_set.rb

@@ -1,4 +1,6 @@
-require 'fear'
+# frozen_string_literal: true
+
+require "fear"
 
 # @example Usage
 #   set = BinaryTreeSet.new
@@ -10,8 +12,11 @@ require 'fear'
 #
 class BinaryTreeSet
   Position = Module.new
+  private_constant(:Position)
   Right = Module.new.include(Position)
+  private_constant(:Right)
   Left = Module.new.include(Position)
+  private_constant(:Left)
 
   def initialize(elem = 0, removed: true)
     @elem = elem
@@ -87,7 +92,7 @@ class BinaryTreeSet
   # @param position [Position]
   # @return [Fear::Option<BinaryTreeSet>]
   private def leaf(position)
-    if subtrees.key?(position)
+    if subtrees.has_key?(position)
       Fear.some(subtrees[position])
     else
       Fear.none

data/examples/pattern_matching_number_in_words.rb

@@ -1,54 +1,60 @@
-require 'fear'
+# frozen_string_literal: true
+
+require "fear"
 
 class ToWords
+  NUMBERS = {
+    0 => "zero",
+    1 => "one",
+    2 => "two",
+    3 => "three",
+    4 => "four",
+    5 => "five",
+    6 => "six",
+    7 => "seven",
+    8 => "eight",
+    9 => "nine",
+    10 => "ten",
+    11 => "eleven",
+    12 => "twelve",
+    13 => "thirteen",
+    14 => "fourteen",
+    15 => "fifteen",
+    16 => "sixteen",
+    17 => "seventeen",
+    18 => "eighteen",
+    19 => "nineteen",
+    20 => "twenty",
+    30 => "thirty",
+    40 => "forty",
+    50 => "fifty",
+    60 => "sixty",
+    70 => "seventy",
+    80 => "eighty",
+    90 => "ninety",
+  }.freeze
+  private_constant :NUMBERS
+
   CONVERTER = Fear.matcher do |m|
-    {
-      0 => 'zero',
-      1 => 'one',
-      2 => 'two',
-      3 => 'three',
-      4 => 'four',
-      5 => 'five',
-      6 => 'six',
-      7 => 'seven',
-      8 => 'eight',
-      9 => 'nine',
-      10 => 'ten',
-      11 => 'eleven',
-      12 => 'twelve',
-      13 => 'thirteen',
-      14 => 'fourteen',
-      15 => 'fifteen',
-      16 => 'sixteen',
-      17 => 'seventeen',
-      18 => 'eighteen',
-      19 => 'nineteen',
-      20 => 'twenty',
-      30 => 'thirty',
-      40 => 'forty',
-      50 => 'fifty',
-      60 => 'sixty',
-      70 => 'seventy',
-      80 => 'eighty',
-      90 => 'ninety',
-    }.each_pair do |number, in_words|
+    NUMBERS.each_pair do |number, in_words|
       m.case(number) { in_words }
     end
-    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.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.else { |n| raise "#{n} too big " }
   end
+  private_constant :CONVERTER
 
   def self.call(number)
-    Fear.case(Integer, &:itself).and_then(CONVERTER).call(number)
+    Fear.case(Integer, &:itself).and_then(CONVERTER).(number)
   end
 end
 
-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'
+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'

data/fear.gemspec

@@ -1,41 +1,40 @@
-lib = File.expand_path('lib', __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require 'fear/version'
+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.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.require_paths = ['lib']
-
-  spec.post_install_message = <<-MSG
-    Fear v0.11.0 introduces backwards-incompatible changes.
-    Please see https://github.com/bolshakov/fear/blob/master/CHANGELOG.md#0110 for details.
-    Successfully installed fear-#{Fear::VERSION}
-  MSG
+  spec.name = "fear"
+  spec.version = Fear::VERSION
+  spec.authors = ["Tema Bolshakov"]
+  spec.email = ["abolshakov@spbtv.com"]
+  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.add_runtime_dependency 'lru_redux'
-  spec.add_runtime_dependency 'treetop'
+  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.require_paths = ["lib"]
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
-  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', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'rubocop', '0.65.0'
-  spec.add_development_dependency 'rubocop-rspec', '1.32.0'
-  spec.add_development_dependency 'yard'
+  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"
 end