fear 0.11.0 → 1.0.0

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

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,15 @@
+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 allowed here'
+  end
+end
+
+matcher.call User.new(1, 'Jane', true)
+matcher.call User.new(1, 'John', false)

data/examples/pattern_matching_binary_tree_set.rb

@@ -0,0 +1,96 @@
+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
+  Right = Module.new.include(Position)
+  Left = Module.new.include(Position)
+
+  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.key?(position)
+      Fear.some(subtrees[position])
+    else
+      Fear.none
+    end
+  end
+end

data/examples/pattern_matching_number_in_words.rb

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

data/fear.gemspec

@@ -24,12 +24,14 @@ Gem::Specification.new do |spec|
     Successfully installed fear-#{Fear::VERSION}
   MSG
 
-  spec.add_runtime_dependency 'dry-equalizer', '<= 0.2.1'
+  spec.add_runtime_dependency 'lru_redux'
+  spec.add_runtime_dependency 'treetop'
 
-  spec.add_development_dependency 'appraisal'
   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'

data/lib/fear.rb

@@ -1,19 +1,34 @@
-require 'dry-equalizer'
-require 'fear/version'
+require 'fear/either_api'
+require 'fear/extractor_api'
+require 'fear/for_api'
+require 'fear/future_api'
+require 'fear/option_api'
 require 'fear/pattern_matching_api'
+require 'fear/try_api'
+require 'fear/version'
 
 module Fear
   Error = Class.new(StandardError)
-  NoSuchElementError = Class.new(Error)
+  IllegalStateException = Class.new(Error)
   MatchError = Class.new(Error)
+  NoSuchElementError = Class.new(Error)
+  PatternSyntaxError = Class.new(Error)
+
+  extend EitherApi
+  extend ExtractorApi
+  extend ForApi
+  extend FutureApi
+  extend OptionApi
   extend PatternMatchingApi
+  extend TryApi
 
   autoload :EmptyPartialFunction, 'fear/empty_partial_function'
   autoload :PartialFunction, 'fear/partial_function'
   autoload :PartialFunctionClass, 'fear/partial_function_class'
   autoload :PatternMatch, 'fear/pattern_match'
+  autoload :Extractor, 'fear/extractor'
 
-  autoload :Done, 'fear/done'
+  autoload :Unit, 'fear/unit'
   autoload :For, 'fear/for'
   autoload :RightBiased, 'fear/right_biased'
   autoload :Utils, 'fear/utils'
@@ -40,6 +55,8 @@ module Fear
   autoload :Right, 'fear/right'
   autoload :RightPatternMatch, 'fear/right_pattern_match'
 
+  autoload :Future, 'fear/future'
+
   module Mixin
     include Either::Mixin
     include For::Mixin

data/lib/fear/either.rb

@@ -14,9 +14,9 @@ module Fear
   # @example
   #   in = Readline.readline('Type Either a string or an Int: ', true)
   #   result = begin
-  #     Right(Integer(in))
+  #     Fear.right(Integer(in))
   #   rescue ArgumentError
-  #     Left(in)
+  #     Fear.left(in)
   #   end
   #
   #   result.match do |m|
@@ -40,21 +40,21 @@ module Fear
   #     @yieldreturn [any]
   #     @return [any]
   #     @example
-  #       Right(42).get_or_else { 24/2 }         #=> 42
-  #       Left('undefined').get_or_else { 24/2 } #=> 12
+  #       Fear.right(42).get_or_else { 24/2 }         #=> 42
+  #       Fear.left('undefined').get_or_else { 24/2 } #=> 12
   #   @overload get_or_else(default)
   #     @return [any]
   #     @example
-  #       Right(42).get_or_else(12)         #=> 42
-  #       Left('undefined').get_or_else(12) #=> 12
+  #       Fear.right(42).get_or_else(12)         #=> 42
+  #       Fear.left('undefined').get_or_else(12) #=> 12
   #
   # @!method or_else(&alternative)
   #   Returns this +Right+ or the given alternative if this is a +Left+.
   #   @return [Either]
   #   @example
-  #     Right(42).or_else { Right(21) }           #=> Right(42)
-  #     Left('unknown').or_else { Right(21) }     #=> Right(21)
-  #     Left('unknown').or_else { Left('empty') } #=> Left('empty')
+  #     Fear.right(42).or_else { Fear.right(21) }           #=> Fear.right(42)
+  #     Fear.left('unknown').or_else { Fear.right(21) }     #=> Fear.right(21)
+  #     Fear.left('unknown').or_else { Fear.left('empty') } #=> Fear.left('empty')
   #
   # @!method include?(other_value)
   #   Returns +true+ if +Right+ has an element that is equal
@@ -62,9 +62,9 @@ module Fear
   #   @param [any]
   #   @return [Boolean]
   #   @example
-  #     Right(17).include?(17)         #=> true
-  #     Right(17).include?(7)          #=> false
-  #     Left('undefined').include?(17) #=> false
+  #     Fear.right(17).include?(17)         #=> true
+  #     Fear.right(17).include?(7)          #=> false
+  #     Fear.left('undefined').include?(17) #=> false
   #
   # @!method each(&block)
   #   Performs the given block if this is a +Right+.
@@ -72,11 +72,11 @@ module Fear
   #   @yieldreturn [void]
   #   @return [Option] itself
   #   @example
-  #     Right(17).each do |value|
+  #     Fear.right(17).each do |value|
   #       puts value
   #     end #=> prints 17
   #
-  #     Left('undefined').each do |value|
+  #     Fear.left('undefined').each do |value|
   #       puts value
   #     end #=> does nothing
   #
@@ -86,8 +86,8 @@ module Fear
   #   @yieldparam [any] value
   #   @yieldreturn [any]
   #   @example
-  #     Right(42).map { |v| v/2 }          #=> Right(21)
-  #     Left('undefined').map { |v| v/2 }  #=> Left('undefined')
+  #     Fear.right(42).map { |v| v/2 }          #=> Fear.right(21)
+  #     Fear.left('undefined').map { |v| v/2 }  #=> Fear.left('undefined')
   #
   # @!method flat_map(&block)
   #   Returns the given block applied to the value from this +Right+
@@ -96,16 +96,16 @@ module Fear
   #   @yieldreturn [Option]
   #   @return [Option]
   #   @example
-  #     Right(42).flat_map { |v| Right(v/2) }         #=> Right(21)
-  #     Left('undefined').flat_map { |v| Right(v/2) } #=> Left('undefined')
+  #     Fear.right(42).flat_map { |v| Fear.right(v/2) }         #=> Fear.right(21)
+  #     Fear.left('undefined').flat_map { |v| Fear.right(v/2) } #=> Fear.left('undefined')
   #
   # @!method to_option
   #   Returns an +Some+ containing the +Right+ value or a +None+ if
   #   this is a +Left+.
   #   @return [Option]
   #   @example
-  #     Right(42).to_option          #=> Some(21)
-  #     Left('undefined').to_option  #=> None()
+  #     Fear.right(42).to_option          #=> Fear.some(21)
+  #     Fear.left('undefined').to_option  #=> Fear.none()
   #
   # @!method any?(&predicate)
   #   Returns +false+ if +Left+ or returns the result of the
@@ -114,9 +114,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Boolean]
   #   @example
-  #     Right(12).any?( |v| v > 10)         #=> true
-  #     Right(7).any?( |v| v > 10)          #=> false
-  #     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
   #
   # -----
   #
@@ -125,16 +125,16 @@ module Fear
   #   @note this method is also aliased as +#success?+
   #   @return [Boolean]
   #   @example
-  #     Right(42).right?   #=> true
-  #     Left('err').right? #=> false
+  #     Fear.right(42).right?   #=> true
+  #     Fear.left('err').right? #=> false
   #
   # @!method left?
   #   Returns +true+ if this is a +Left+, +false+ otherwise.
   #   @note this method is also aliased as +#failure?+
   #   @return [Boolean]
   #   @example
-  #     Right(42).left?   #=> false
-  #     Left('err').left? #=> true
+  #     Fear.right(42).left?   #=> false
+  #     Fear.left('err').left? #=> true
   #
   # @!method select_or_else(default, &predicate)
   #   Returns +Left+ of the default if the given predicate
@@ -144,10 +144,10 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Either]
   #   @example
-  #     Right(12).select_or_else(-1, &:even?)       #=> Right(12)
-  #     Right(7).select_or_else(-1, &:even?)        #=> Left(-1)
-  #     Left(12).select_or_else(-1, &:even?)        #=> Left(12)
-  #     Left(12).select_or_else(-> { -1 }, &:even?) #=> Left(12)
+  #     Fear.right(12).select_or_else(-1, &:even?)       #=> Fear.right(12)
+  #     Fear.right(7).select_or_else(-1, &:even?)        #=> Fear.left(-1)
+  #     Fear.left(12).select_or_else(-1, &:even?)        #=> Fear.left(12)
+  #     Fear.left(12).select_or_else(-> { -1 }, &:even?) #=> Fear.left(12)
   #
   # @!method select(&predicate)
   #   Returns +Left+ of value if the given predicate
@@ -156,10 +156,10 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Either]
   #   @example
-  #     Right(12).select(&:even?) #=> Right(12)
-  #     Right(7).select(&:even?)  #=> Left(7)
-  #     Left(12).select(&:even?)  #=> Left(12)
-  #     Left(7).select(&:even?)   #=> Left(7)
+  #     Fear.right(12).select(&:even?) #=> Fear.right(12)
+  #     Fear.right(7).select(&:even?)  #=> Fear.left(7)
+  #     Fear.left(12).select(&:even?)  #=> Fear.left(12)
+  #     Fear.left(7).select(&:even?)   #=> Fear.left(7)
   #
   # @!method reject(&predicate)
   #   Returns +Left+ of value if the given predicate holds for the
@@ -168,17 +168,17 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Either]
   #   @example
-  #     Right(12).reject(&:even?) #=> Left(12)
-  #     Right(7).reject(&:even?)  #=> Right(7)
-  #     Left(12).reject(&:even?)  #=> Left(12)
-  #     Left(7).reject(&:even?)   #=> Left(7)
+  #     Fear.right(12).reject(&:even?) #=> Fear.left(12)
+  #     Fear.right(7).reject(&:even?)  #=> Fear.right(7)
+  #     Fear.left(12).reject(&:even?)  #=> Fear.left(12)
+  #     Fear.left(7).reject(&:even?)   #=> Fear.left(7)
   #
   # @!method swap
   #   If this is a +Left+, then return the left value in +Right+ or vice versa.
   #   @return [Either]
   #   @example
-  #     Left('left').swap   #=> Right('left')
-  #     Right('right').swap #=> Light('left')
+  #     Fear.left('left').swap   #=> Fear.right('left')
+  #     Fear.right('right').swap #=> Fear.left('left')
   #
   # @!method reduce(reduce_left, reduce_right)
   #   Applies +reduce_left+ if this is a +Left+ or +reduce_right+ if
@@ -204,10 +204,10 @@ module Fear
   #   @return [Either]
   #   @raise [TypeError] if it does not contain +Either+.
   #   @example
-  #     Right(Right(12)).join_right      #=> Right(12)
-  #     Right(Left("flower")).join_right #=> Left("flower")
-  #     Left("flower").join_right        #=> Left("flower")
-  #     Left(Right("flower")).join_right #=> Left(Right("flower"))
+  #     Fear.right(Fear.right(12)).join_right      #=> Fear.right(12)
+  #     Fear.right(Fear.left("flower")).join_right #=> Fear.left("flower")
+  #     Fear.left("flower").join_right             #=> Fear.left("flower")
+  #     Fear.left(Fear.right("flower")).join_right #=> Fear.left(Fear.right("flower"))
   #
   # @!method join_right
   #   Joins an +Either+ through +Left+. This method requires
@@ -217,16 +217,16 @@ module Fear
   #   @return [Either]
   #   @raise [TypeError] if it does not contain +Either+.
   #   @example
-  #     Left(Right("flower")).join_left #=> Right("flower")
-  #     Left(Left(12)).join_left        #=> Left(12)
-  #     Right("daisy").join_left        #=> Right("daisy")
-  #     Right(Left("daisy")).join_left  #=> Right(Left("daisy"))
+  #     Fear.left(Fear.right("flower")).join_left   #=> Fear.right("flower")
+  #     Fear.left(Fear.left(12)).join_left          #=> Fear.left(12)
+  #     Fear.right("daisy").join_left               #=> Fear.right("daisy")
+  #     Fear.right(Fear.left("daisy")).join_left    #=> Fear.right(Fear.left("daisy"))
   #
   # @!method match(&matcher)
   #   Pattern match against this +Either+
   #   @yield matcher [Fear::EitherPatternMatch]
   #   @example
-  #     Either(val).match do |m|
+  #     either.match do |m|
   #       m.right(Integer) do |x|
   #        x * 2
   #       end
@@ -242,8 +242,6 @@ module Fear
   # @see https://github.com/scala/scala/blob/2.12.x/src/library/scala/util/Either.scala
   #
   module Either
-    include Dry::Equalizer(:value)
-
     # @private
     def left_class
       Left
@@ -261,6 +259,20 @@ module Fear
     attr_reader :value
     protected :value
 
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(self.class) && value == other.value
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class} value=#{value.inspect}>"
+    end
+
+    # @return [String]
+    alias to_s inspect
+
     class << self
       # Build pattern matcher to be used later, despite off
       # +Either#match+ method, id doesn't apply matcher immanently,
@@ -275,7 +287,7 @@ module Fear
       #       m.left(String) { :err }
       #       m.else { 'error '}
       #     end
-      #   matcher.call(Some(42))
+      #   matcher.call(Fear.right(42))
       #
       # @yieldparam [Fear::EitherPatternMatch]
       # @return [Fear::PartialFunction]
@@ -292,16 +304,22 @@ module Fear
     #   Left('beaf')    #=> #<Fear::Legt value='beaf'>
     #
     module Mixin
-      # @param [any]
-      # @return [Left]
+      # @param value [any]
+      # @return [Fear::Left]
+      # @example
+      #   Left(42) #=> #<Fear::Left value=42>
+      #
       def Left(value)
-        Left.new(value)
+        Fear.left(value)
       end
 
-      # @param [any]
-      # @return [Right]
+      # @param value [any]
+      # @return [Fear::Right]
+      # @example
+      #   Right(42) #=> #<Fear::Right value=42>
+      #
       def Right(value)
-        Right.new(value)
+        Fear.right(value)
       end
     end
   end