Move pattern match files out of the main namespace

lib/fear/either.rb

@@ -226,7 +226,7 @@ module Fear
   #
   # @!method match(&matcher)
   #   Pattern match against this +Either+
-  #   @yield matcher [Fear::EitherPatternMatch]
+  #   @yield matcher [Fear::Either::PatternMatch]
   #   @example
   #     either.match do |m|
   #       m.right(Integer) do |x|
@@ -309,10 +309,10 @@ class << self
       #     end
       #   matcher.call(Fear.right(42))
       #
-      # @yieldparam [Fear::EitherPatternMatch]
+      # @yieldparam [Fear::Either::PatternMatch]
       # @return [Fear::PartialFunction]
       def matcher(&matcher)
-        EitherPatternMatch.new(&matcher)
+        Either::PatternMatch.new(&matcher)
       end
     end
 
@@ -345,7 +345,7 @@ def Right(value)
   end
 end
 
-require "fear/either_pattern_match"
+require "fear/either/pattern_match"
 require "fear/left"
 require "fear/right"
 require "fear/either/left_projection"

lib/fear/either/pattern_match.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
+module Fear
+  module Either
+    # Either pattern matcher
+    #
+    # @example
+    #   pattern_match =
+    #     EitherPatternMatch.new
+    #       .right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+    #       .right(String) { |x| x.to_i * 2 }
+    #       .left(String) { :err }
+    #       .else { 'error '}
+    #
+    #   pattern_match.call(42) => 'NaN'
+    #
+    #  @example the same matcher may be defined using block syntax
+    #    EitherPatternMatch.new do |m|
+    #      m.right(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+    #      m.right(String) { |x| x.to_i * 2 }
+    #      m.left(String) { :err }
+    #      m.else { 'error '}
+    #    end
+    #
+    # @note it has two optimized subclasses +Fear::Left::PatternMatch+ and +Fear::Right::PatternMatch+
+    # @api private
+    class PatternMatch < Fear::PatternMatch
+      # Match against +Fear::Right+
+      #
+      # @param conditions [<#==>]
+      # @return [Fear::Either::PatternMatch]
+      def right(*conditions, &effect)
+        branch = Fear.case(Fear::Right, &:right_value).and_then(Fear.case(*conditions, &effect))
+        or_else(branch)
+      end
+      alias success right
+
+      # Match against +Fear::Left+
+      #
+      # @param conditions [<#==>]
+      # @return [Fear::Either::PatternMatch]
+      def left(*conditions, &effect)
+        branch = Fear.case(Fear::Left, &:left_value).and_then(Fear.case(*conditions, &effect))
+        or_else(branch)
+      end
+      alias failure left
+    end
+  end
+end

lib/fear/failure.rb

@@ -4,7 +4,7 @@ module Fear
   class Failure
     include Try
     include RightBiased::Left
-    include FailurePatternMatch.mixin
+    include Failure::PatternMatch.mixin
 
     # @param [StandardError]
     def initialize(exception)
@@ -103,3 +103,5 @@ def deconstruct
     end
   end
 end
+
+require "fear/failure/pattern_match"

lib/fear/failure/pattern_match.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fear
+  class Failure
+    # @api private
+    class PatternMatch < Try::PatternMatch
+      def success(*_conditions)
+        self
+      end
+    end
+
+    private_constant :PatternMatch
+  end
+end

lib/fear/future.rb

@@ -170,7 +170,7 @@ def on_complete
     #
     # If the future has already been completed,
     # this will either be applied immediately or be scheduled asynchronously.
-    # @yieldparam [Fear::TryPatternMatch]
+    # @yieldparam [Fear::Try::PatternMatch]
     # @return [self]
     #
     # @example

lib/fear/left.rb

@@ -4,7 +4,7 @@ module Fear
   class Left
     include Either
     include RightBiased::Left
-    include LeftPatternMatch.mixin
+    include Left::PatternMatch.mixin
 
     # @api private
     def left_value
@@ -74,3 +74,5 @@ def ===(other)
     end
   end
 end
+
+require "fear/left/pattern_match"

lib/fear/left/pattern_match.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fear
+  class Left
+    # @api private
+    class PatternMatch < Fear::Either::PatternMatch
+      def right(*)
+        self
+      end
+      alias success right
+    end
+
+    private_constant :PatternMatch
+  end
+end

lib/fear/none.rb

@@ -5,7 +5,7 @@ module Fear
   class NoneClass
     include Option
     include RightBiased::Left
-    include NonePatternMatch.mixin
+    include NoneClass::PatternMatch.mixin
 
     # @raise [NoSuchElementError]
     def get
@@ -92,3 +92,5 @@ def inherited(*)
     end
   end
 end
+
+require "fear/none_class/pattern_match"

lib/fear/none_class/pattern_match.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fear
+  class NoneClass
+    # @api private
+    class PatternMatch < Option::PatternMatch
+      # @param conditions [<#==>]
+      # @return [Fear::OptionPatternMatch]
+      def some(*conditions)
+        self
+      end
+    end
+
+    private_constant :PatternMatch
+  end
+end

lib/fear/option.rb

@@ -207,7 +207,7 @@ class << self
       # @yieldparam [OptionPatternMatch]
       # @return [Fear::PartialFunction]
       def matcher(&matcher)
-        OptionPatternMatch.new(&matcher)
+        Option::PatternMatch.new(&matcher)
       end
 
       def match(value, &block)
@@ -259,6 +259,6 @@ def Some(value)
   end
 end
 
-require "fear/option_pattern_match"
+require "fear/option/pattern_match"
 require "fear/some"
 require "fear/none"

lib/fear/option/pattern_match.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
+module Fear
+  module Option
+    # Option pattern matcher
+    #
+    # @example
+    #   pattern_match =
+    #     Option::PatternMatch.new
+    #       .some(Integer) { |x| x * 2 }
+    #       .some(String) { |x| x.to_i * 2 }
+    #       .none { 'NaN' }
+    #       .else { 'error '}
+    #
+    #   pattern_match.call(42) => 'NaN'
+    #
+    #  @example the same matcher may be defined using block syntax
+    #    Option::PatternMatch.new do |m|
+    #       m.some(Integer) { |x| x * 2 }
+    #       m.some(String) { |x| x.to_i * 2 }
+    #       m.none { 'NaN' }
+    #       m.else { 'error '}
+    #    end
+    #
+    # @note it has two optimized subclasses +Fear::SomePatternMatch+ and +Fear::NonePatternMatch+
+    # @api private
+    class PatternMatch < Fear::PatternMatch
+      # Match against Some
+      #
+      # @param conditions [<#==>]
+      # @return [Fear::Option::PatternMatch]
+      def some(*conditions, &effect)
+        branch = Fear.case(Fear::Some, &:get).and_then(Fear.case(*conditions, &effect))
+        or_else(branch)
+      end
+
+      # Match against None
+      #
+      # @param effect [Proc]
+      # @return [Fear::Option::PatternMatch]
+      def none(&effect)
+        branch = Fear.case(Fear::None, &effect)
+        or_else(branch)
+      end
+    end
+  end
+end