fear 0.10.0 → 0.11.0

data/lib/fear/either.rb

@@ -19,12 +19,15 @@ module Fear
   #     Left(in)
   #   end
   #
-  #   puts(
-  #     result.reduce(
-  #       -> (x) { "You passed me the String: #{x}" },
-  #       -> (x) { "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}" }
-  #     )
-  #   )
+  #   result.match do |m|
+  #     m.right do |x|
+  #       "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}"
+  #     end
+  #
+  #     m.left do |x|
+  #       "You passed me the String: #{x}"
+  #     end
+  #   end
   #
   # Either is right-biased, which means that +Right+ is assumed to be the default case to
   # operate on. If it is +Left+, operations like +#map+, +#flat_map+, ... return the +Left+ value
@@ -96,14 +99,6 @@ module Fear
   #     Right(42).flat_map { |v| Right(v/2) }         #=> Right(21)
   #     Left('undefined').flat_map { |v| Right(v/2) } #=> Left('undefined')
   #
-  # @!method to_a
-  #   Returns an +Array+ containing the +Right+ value or an
-  #   empty +Array+ if this is a +Left+.
-  #   @return [Array]
-  #   @example
-  #     Right(42).to_a          #=> [21]
-  #     Left('undefined').to_a  #=> []
-  #
   # @!method to_option
   #   Returns an +Some+ containing the +Right+ value or a +None+ if
   #   this is a +Left+.
@@ -227,6 +222,23 @@ module Fear
   #     Right("daisy").join_left        #=> Right("daisy")
   #     Right(Left("daisy")).join_left  #=> Right(Left("daisy"))
   #
+  # @!method match(&matcher)
+  #   Pattern match against this +Either+
+  #   @yield matcher [Fear::EitherPatternMatch]
+  #   @example
+  #     Either(val).match do |m|
+  #       m.right(Integer) do |x|
+  #        x * 2
+  #       end
+  #
+  #       m.right(String) do |x|
+  #         x.to_i * 2
+  #       end
+  #
+  #       m.left { |x| x }
+  #       m.else { 'something unexpected' }
+  #     end
+  #
   # @see https://github.com/scala/scala/blob/2.12.x/src/library/scala/util/Either.scala
   #
   module Either
@@ -249,6 +261,29 @@ module Fear
     attr_reader :value
     protected :value
 
+    class << self
+      # Build pattern matcher to be used later, despite off
+      # +Either#match+ method, id doesn't apply matcher immanently,
+      # but build it instead. Unusually in sake of efficiency it's better
+      # to statically build matcher and reuse it later.
+      #
+      # @example
+      #   matcher =
+      #     Either.matcher 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
+      #   matcher.call(Some(42))
+      #
+      # @yieldparam [Fear::EitherPatternMatch]
+      # @return [Fear::PartialFunction]
+      def matcher(&matcher)
+        EitherPatternMatch.new(&matcher)
+      end
+    end
+
     # Include this mixin to access convenient factory methods.
     # @example
     #   include Fear::Either::Mixin

data/lib/fear/either_pattern_match.rb

@@ -0,0 +1,48 @@
+module Fear
+  # 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::LeftPatternMatch+ and +Fear::RightPatternMatch+
+  # @api private
+  class EitherPatternMatch < Fear::PatternMatch
+    LEFT_EXTRACTOR = :left_value.to_proc
+    RIGHT_EXTRACTOR = :right_value.to_proc
+
+    # Match against +Fear::Right+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::EitherPatternMatch]
+    def right(*conditions, &effect)
+      branch = Fear.case(Fear::Right, &RIGHT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+    alias success right
+
+    # Match against +Fear::Left+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::EitherPatternMatch]
+    def left(*conditions, &effect)
+      branch = Fear.case(Fear::Left, &LEFT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+    alias failure left
+  end
+end

data/lib/fear/empty_partial_function.rb

@@ -0,0 +1,36 @@
+module Fear
+  # Use singleton version of EmptyPartialFunction -- PartialFunction::EMPTY
+  # @api private
+  module EmptyPartialFunction
+    include PartialFunction
+
+    def defined_at?(_)
+      false
+    end
+
+    def call(arg)
+      raise MatchError, "partial function not defined at: #{arg}"
+    end
+
+    alias === call
+    alias [] call
+
+    def call_or_else(arg)
+      yield arg
+    end
+
+    def or_else(other)
+      other
+    end
+
+    def and_then(*)
+      self
+    end
+
+    def to_s
+      'Empty partial function'
+    end
+  end
+
+  private_constant :EmptyPartialFunction
+end

data/lib/fear/failure.rb

@@ -3,6 +3,7 @@ module Fear
     include Try
     include Dry::Equalizer(:exception)
     include RightBiased::Left
+    include FailurePatternMatch.mixin
 
     # @param [StandardError]
     def initialize(exception)
@@ -23,13 +24,13 @@ module Fear
 
     # @raise
     def get
-      fail exception
+      raise exception
     end
 
     # @return [Try] of calling block
     def or_else(*args)
       super
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 
@@ -50,7 +51,7 @@ module Fear
       yield(exception).tap do |result|
         Utils.assert_type!(result, Success, Failure)
       end
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 
@@ -59,7 +60,7 @@ module Fear
     # @return [Try]
     def recover
       Success.new(yield(exception))
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 

data/lib/fear/failure_pattern_match.rb

@@ -0,0 +1,8 @@
+module Fear
+  # @api private
+  class FailurePatternMatch < Fear::TryPatternMatch
+    def success(*_conditions)
+      self
+    end
+  end
+end

data/lib/fear/for.rb

@@ -4,18 +4,20 @@ module Fear
   # operations - +flat_map+ and +map+. Any class providing them
   # is supported by +For+.
   #
-  #     For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
+  #     For(Some(2), Some(3)) do |a, b|
+  #       a * b
+  #     end #=> Some(6)
   #
   # If one of operands is None, the result is None
   #
-  #     For(a: Some(2), b: None()) { a * b } #=> None()
-  #     For(a: None(), b: Some(2)) { a * b } #=> None()
+  #     For(Some(2), None()) { |a, b| a * b } #=> None()
+  #     For(None(), Some(2)) { |a, b| a * b } #=> None()
   #
   # Lets look at first example:
   #
-  #     For(a: Some(2), b: Some(3)) { a * b }
+  #     For(Some(2), Some(3)) { |a, b| a * b }
   #
-  # would be translated to:
+  # it is translated to:
   #
   #     Some(2).flat_map do |a|
   #       Some(3).map do |b|
@@ -25,10 +27,10 @@ module Fear
   #
   # It works with arrays as well
   #
-  #     For(a: [1, 2], b: [2, 3], c: [3, 4]) { a * b * c }
+  #     For([1, 2], [2, 3], [3, 4]) { |a, b, c| a * b * c }
   #       #=> [6, 8, 9, 12, 12, 16, 18, 24]
   #
-  # would be translated to:
+  # it is translated to:
   #
   #     [1, 2].flat_map do |a|
   #       [2, 3].flat_map do |b|
@@ -38,59 +40,52 @@ module Fear
   #       end
   #     end
   #
-  # If you pass lambda as a variable value, it would be evaluated
+  # If you pass lambda instead of monad, it would be evaluated
   # only on demand.
   #
-  #     For(a: -> { None() }, b: -> { fail 'kaboom' } ) { a * b }
-  #       #=> None()
+  #     For(proc { None() }, proc { raise 'kaboom' } ) do |a, b|
+  #       a * b
+  #     end #=> None()
   #
   # It does not fail since `b` is not evaluated.
-  # You can refer to previously defined variables from within lambdas.
+  # You can refer to previously defined monads from within lambdas.
   #
   #     maybe_user = find_user('Paul') #=> <#Option value=<#User ...>>
   #
-  #     For(user: maybe_user, birthday: -> { user.birthday }) do
+  #     For(maybe_user, ->(user) { user.birthday }) do |user, birthday|
   #       "#{user.name} was born on #{birthday}"
   #     end #=> Some('Paul was born on 1987-06-17')
   #
-  class For
-    require_relative 'for/evaluation_context'
+  module For
+    module_function # rubocop: disable Style/AccessModifierDeclarations
 
-    # @param variables [Hash{Symbol => any}]
+    # @param monads [<Fear::Option, Fear::Either, Fear::Try, Proc>]
     #
-    def initialize(outer_context, **variables)
-      @variables = variables
-      @evaluation_context = EvaluationContext.new(outer_context)
-    end
+    def call(monads, inner_values = [], &block)
+      head, *tail = *monads
 
-    def call(&block)
-      variable_name_and_monad, *tail = *variables
-      execute(*variable_name_and_monad, tail, &block)
+      if tail.length.zero?
+        map(head, inner_values, &block)
+      else
+        flat_map(head, tail, inner_values, &block)
+      end
     end
 
-    private
-
-    attr_reader :variables
-    attr_reader :evaluation_context
+    private def map(head, inner_values)
+      resolve(head, inner_values).map do |x|
+        yield(*inner_values, x)
+      end
+    end
 
-    def execute(variable_name, monad, monads, &block) # rubocop:disable Metrics/MethodLength
-      if monads.empty?
-        resolve(monad).map do |value|
-          evaluation_context.__assign__(variable_name, value)
-          evaluation_context.instance_exec(&block)
-        end
-      else
-        resolve(monad).flat_map do |value|
-          evaluation_context.__assign__(variable_name, value)
-          variable_name_and_monad, *tail = *monads
-          execute(*variable_name_and_monad, tail, &block)
-        end
+    private def flat_map(head, tail, inner_values, &block)
+      resolve(head, inner_values).flat_map do |x|
+        call(tail, inner_values + [x], &block)
       end
     end
 
-    def resolve(monad_or_proc)
+    private def resolve(monad_or_proc, inner_values)
       if monad_or_proc.respond_to?(:call)
-        evaluation_context.instance_exec(&monad_or_proc)
+        monad_or_proc.call(*inner_values)
       else
         monad_or_proc
       end
@@ -100,29 +95,29 @@ module Fear
     # @example
     #   include Fear::For::Mixin
     #
-    #   For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
-    #   For(a: Some(2), b: None()) { a * b }  #=> None()
+    #   For(Some(2), Some(3)) { |a, b| a * b } #=> Some(6)
+    #   For(Some(2), None()) { |a, b| a * b }  #=> None()
     #
-    #   For(a: -> { Some(2) }, b: -> { Some(3) }) do
+    #   For(proc { Some(2) }, proc { Some(3) }) do |a, b|
     #     a * b
     #   end #=> Some(6)
     #
-    #   For(a: -> { None() }, b: -> { fail }) do
+    #   For(proc { None() }, proc { raise }) do |a, b|
     #     a * b
     #   end #=> None()
     #
-    #   For(a: Right(2), b: Right(3)) { a * b } #=> Right(6)
-    #   For(a: Right(2), b: Left(3)) { a * b }  #=> Left(3)
+    #   For(Right(2), Right(3)) { |a, b| a * b } #=> Right(6)
+    #   For(Right(2), Left(3)) { |a, b| a * b }  #=> Left(3)
     #
-    #   For(a: Success(2), b: Success(3)) { a * b }    #=> Success(3)
-    #   For(a: Success(2), b: Failure(...)) { a * b }  #=> Failure(...)
+    #   For(Success(2), Success(3)) { |a| a * b } #=> Success(3)
+    #   For(Success(2), Failure(...)) { |a, b| a * b }  #=> Failure(...)
     #
     module Mixin
-      # @param locals [Hash{Symbol => {#map, #flat_map}}]
+      # @param monads [Hash{Symbol => {#map, #flat_map}}]
       # @return [{#map, #flat_map}]
       #
-      def For(**locals, &block)
-        For.new(self, **locals).call(&block)
+      def For(*monads, &block)
+        For.call(monads, &block)
       end
     end
   end

data/lib/fear/left.rb

@@ -2,6 +2,12 @@ module Fear
   class Left
     include Either
     include RightBiased::Left
+    include LeftPatternMatch.mixin
+
+    # @api private
+    def left_value
+      value
+    end
 
     # @return [false]
     def right?
@@ -37,7 +43,7 @@ module Fear
 
     # @param reduce_left [Proc]
     # @return [any]
-    def reduce(reduce_left, _)
+    def reduce(reduce_left, _reduce_right)
       reduce_left.call(value)
     end
 

data/lib/fear/left_pattern_match.rb

@@ -0,0 +1,9 @@
+module Fear
+  # @api private
+  class LeftPatternMatch < Fear::EitherPatternMatch
+    def right(*)
+      self
+    end
+    alias success right
+  end
+end

data/lib/fear/none.rb

@@ -1,12 +1,14 @@
 module Fear
-  class None
+  # @api private
+  class NoneClass
     include Option
     include Dry::Equalizer()
     include RightBiased::Left
+    include NonePatternMatch.mixin
 
     # @raise [NoSuchElementError]
     def get
-      fail NoSuchElementError
+      raise NoSuchElementError
     end
 
     # @return [nil]
@@ -28,5 +30,38 @@ module Fear
     def reject(*)
       self
     end
+
+    AS_STRING = 'Fear::None'.freeze
+
+    # @return [String]
+    def to_s
+      AS_STRING
+    end
+
+    # @return [String]
+    def inspect
+      AS_STRING
+    end
+
+    # @param other
+    # @return [Boolean]
+    def ===(other)
+      self == other
+    end
+  end
+
+  private_constant(:NoneClass)
+
+  # The only instance of NoneClass
+  None = NoneClass.new.freeze
+
+  class << NoneClass
+    def new
+      None
+    end
+
+    def inherited
+      raise 'you are not allowed to inherit from NoneClass, use Fear::None instead'
+    end
   end
 end

data/lib/fear/none_pattern_match.rb

@@ -0,0 +1,12 @@
+module Fear
+  # @api private
+  class NonePatternMatch < OptionPatternMatch
+    # @param conditions [<#==>]
+    # @return [Fear::OptionPatternMatch]
+    def some(*_conditions)
+      self
+    end
+  end
+
+  private_constant :NonePatternMatch
+end