fear 0.9.0 → 1.2.0

data/benchmarks/fear_pattern_extracting_with_vs_without_cache.txt

@@ -0,0 +1,11 @@
+> bundle exec rake perf:fear:pattern_extracting_with_vs_without_cache
+Warming up --------------------------------------
+          With cache     1.555k i/100ms
+       Without cache   164.000  i/100ms
+Calculating -------------------------------------
+          With cache     26.159M (±14.7%) i/s -    124.607M in   4.958175s
+       Without cache    278.285k (±10.5%) i/s -      1.368M in   4.993567s
+
+Comparison:
+          With cache: 26159162.8 i/s
+       Without cache:   278285.4 i/s - 94.00x  slower

data/benchmarks/fear_pattern_matching_construction_vs_execution.txt

@@ -0,0 +1,13 @@
+# So, it's better to avoid building pattern match in runtime
+
+> bundle exec rake perf:fear:pattern_matching_construction_vs_execution
+Warming up --------------------------------------
+        construction    24.425k i/100ms
+           execution    80.516k 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
+
+Comparison:
+           execution:  1084968.2 i/s
+        construction:   267886.6 i/s - 4.05x  slower

data/benchmarks/pattern_matching_dry_vs_qo_vs_fear_try.txt

@@ -0,0 +1,14 @@
+> bundle exec rake perf:pattern_matching:dry_vs_qo_vs_fear_try
+Warming up --------------------------------------
+                  Qo     2.958k i/100ms
+                Fear     7.127k i/100ms
+         Dr::Matcher    13.079k 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
+
+Comparison:
+         Dr::Matcher:   166699.7 i/s
+                Fear:    88755.7 i/s - 1.88x  slower
+                  Qo:    38871.9 i/s - 4.29x  slower

data/benchmarks/pattern_matching_qo_vs_fear_pattern_extraction.txt

@@ -0,0 +1,11 @@
+> bundle exec rake perf:pattern_matching:qo_vs_fear_pattern_extraction
+Warming up --------------------------------------
+                  Qo    12.352k i/100ms
+                Fear     6.841k i/100ms
+Calculating -------------------------------------
+                  Qo    142.416k (± 4.3%) i/s -    716.416k in   5.040430s
+                Fear     88.179k (± 4.8%) i/s -    444.665k in   5.055908s
+
+Comparison:
+                  Qo:   142415.6 i/s
+                Fear:    88179.5 i/s - 1.62x  slower

data/benchmarks/pattern_matching_qo_vs_fear_try_execution.txt

@@ -0,0 +1,11 @@
+> bundle exec rake perf:pattern_matching:qo_vs_fear_try_execution
+Warming up --------------------------------------
+                  Qo    10.079k i/100ms
+                Fear    25.868k i/100ms
+Calculating -------------------------------------
+                  Qo    142.209k (± 3.8%) i/s -    715.609k in   5.039975s
+                Fear    395.999k (± 2.5%) i/s -      1.992M in   5.033046s
+
+Comparison:
+                Fear:   395999.2 i/s
+                  Qo:   142209.4 i/s - 2.78x  slower

data/examples/pattern_extracting.rb

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

data/examples/pattern_extracting_ruby2.7.rb

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

data/examples/pattern_matching_binary_tree_set.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "fear"
+
+# @example Usage
+#   set = BinaryTreeSet.new
+#   set.add(4)
+#   set.includes?(4) #=> true
+#   set.includes?(5) #=> false
+#   set.delete(4)
+#   set.includes?(4) #=> false
+#
+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
+    @removed = removed
+    @subtrees = {}
+  end
+  attr_reader :elem, :subtrees
+  attr_accessor :removed
+  private :elem
+  private :removed
+  private :subtrees
+
+  # @param value [Integer]
+  # @return [Boolean]
+  def includes?(value)
+    Fear.match(value) do |m|
+      m.case(elem) { !removed }
+      m.case(->(x) { x > elem }) { |v| includes_in_leaf?(Right, v) }
+      m.case(->(x) { x < elem }) { |v| includes_in_leaf?(Left, v) }
+    end
+  end
+
+  # @param position [Position]
+  # @param value [Integer]
+  # @return [Boolean]
+  private def includes_in_leaf?(position, value)
+    leaf(position).match do |m|
+      m.some { |leaf| leaf.includes?(value) }
+      m.none { false }
+    end
+  end
+
+  # @param value [Integer]
+  # @return [void]
+  def add(value)
+    Fear.match(value) do |m|
+      m.case(elem) { self.removed = false }
+      m.case(->(x) { x > elem }) { |v| add_to_leaf(Right, v) }
+      m.case(->(x) { x < elem }) { |v| add_to_leaf(Left, v) }
+    end
+  end
+
+  # @param position [Position]
+  # @param value [Integer]
+  # @return [void]
+  private def add_to_leaf(position, value)
+    leaf(position).match do |m|
+      m.some { |leaf| leaf.add(value) }
+      m.none { subtrees[position] = BinaryTreeSet.new(value, removed: false) }
+    end
+  end
+
+  # @param value [Integer]
+  # @return [void]
+  def delete(value)
+    Fear.match(value) do |m|
+      m.case(elem) { self.removed = true }
+      m.case(->(x) { x > elem }) { |v| delete_from_leaf(Right, v) }
+      m.case(->(x) { x < elem }) { |v| delete_from_leaf(Left, v) }
+    end
+  end
+
+  # @param position [Position]
+  # @param value [Integer]
+  # @return [void]
+  private def delete_from_leaf(position, value)
+    leaf(position).match do |m|
+      m.some { |leaf| leaf.delete(value) }
+      m.none { subtrees[position] = BinaryTreeSet.new(value, removed: true) }
+    end
+  end
+
+  # @param position [Position]
+  # @return [Fear::Option<BinaryTreeSet>]
+  private def leaf(position)
+    if subtrees.has_key?(position)
+      Fear.some(subtrees[position])
+    else
+      Fear.none
+    end
+  end
+end

data/examples/pattern_matching_number_in_words.rb

@@ -0,0 +1,60 @@
+# 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|
+    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.else { |n| raise "#{n} too big " }
+  end
+  private_constant :CONVERTER
+
+  def self.call(number)
+    Fear.case(Integer, &:itself).and_then(CONVERTER).(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'

data/fear.gemspec

@@ -1,31 +1,42 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# 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.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.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.add_runtime_dependency 'dry-equalizer', '0.2.0'
+  spec.add_runtime_dependency "lru_redux"
+  spec.add_runtime_dependency "treetop"
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'spbtv_code_style'
-  spec.add_development_dependency 'rubocop-rspec', '1.13.0'
-  spec.add_development_dependency 'rubocop', '0.47.1'
-  spec.add_development_dependency 'simplecov'
+  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.0.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

data/lib/dry/types/fear.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "dry/types"
+require "fear"
+
+Dry::Types.register_extension(:fear_option) do
+  require "dry/types/fear/option"
+end

data/lib/dry/types/fear/option.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    class Option
+      include Type
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
+      include Decorator
+      include Builder
+      include Printable
+
+      # @param [Fear::Option, Object] input
+      #
+      # @return [Fear::Option]
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
+        case input
+        when ::Fear::Option
+          input
+        when Undefined
+          Fear.none
+        else
+          Fear.option(type.call_unsafe(input))
+        end
+      end
+
+      # @param [Fear::Option, Object] input
+      #
+      # @return [Fear::Option]
+      #
+      # @api private
+      def call_safe(input = Undefined)
+        case input
+        when ::Fear::Option
+          input
+        when Undefined
+          Fear.none
+        else
+          Fear.option(type.call_safe(input) { |output = input| return yield(output) })
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def try(input = Undefined)
+        result = type.try(input)
+
+        if result.success?
+          Result::Success.new(Fear.option(result.input))
+        else
+          result
+        end
+      end
+
+      # @return [true]
+      #
+      # @api public
+      def default?
+        true
+      end
+
+      # @param [Object] value
+      #
+      # @see Dry::Types::Builder#default
+      #
+      # @raise [ArgumentError] if nil provided as default value
+      #
+      # @api public
+      def default(value)
+        if value.nil?
+          raise ArgumentError, "nil cannot be used as a default of a maybe type"
+        else
+          super
+        end
+      end
+    end
+
+    module Builder
+      # Turn a type into a maybe type
+      #
+      # @return [Option]
+      #
+      # @api public
+      def option
+        Option.new(Types["nil"] | self)
+      end
+    end
+
+    # @api private
+    class Schema
+      class Key
+        # @api private
+        def option
+          __new__(type.option)
+        end
+      end
+    end
+
+    # @api private
+    class Printer
+      MAPPING[Option] = :visit_option
+
+      # @api private
+      def visit_option(maybe)
+        visit(maybe.type) do |type|
+          yield "Fear::Option<#{type}>"
+        end
+      end
+    end
+
+    # Register non-coercible maybe types
+    NON_NIL.each_key do |name|
+      register("option.strict.#{name}", self[name.to_s].option)
+    end
+
+    # Register coercible maybe types
+    COERCIBLE.each_key do |name|
+      register("option.coercible.#{name}", self["coercible.#{name}"].option)
+    end
+  end
+end