fear 0.9.0 → 1.2.0

data/lib/fear/success.rb

@@ -1,8 +1,19 @@
+# frozen_string_literal: true
+
 module Fear
   class Success
     include Try
-    include Dry::Equalizer(:value)
     include RightBiased::Right
+    include SuccessPatternMatch.mixin
+
+    EXTRACTOR = proc do |try|
+      if Fear::Success === try
+        Fear.some([try.get])
+      else
+        Fear.none
+      end
+    end
+    public_constant :EXTRACTOR
 
     attr_reader :value
     protected :value
@@ -48,9 +59,9 @@ module Fear
       if yield(value)
         self
       else
-        fail NoSuchElementError, "Predicate does not hold for `#{value}`"
+        raise NoSuchElementError, "Predicate does not hold for `#{value}`"
       end
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 
@@ -67,14 +78,14 @@ module Fear
     # @return [Try]
     def map
       super
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 
     # @return [Try]
     def flat_map
       super
-    rescue => error
+    rescue StandardError => error
       Failure.new(error)
     end
 
@@ -82,5 +93,24 @@ module Fear
     def to_either
       Right.new(value)
     end
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Success) && value == other.value
+    end
+
+    # @return [String]
+    def inspect
+      "#<Fear::Success value=#{value.inspect}>"
+    end
+
+    # @return [String]
+    alias to_s inspect
+
+    # @return [<any>]
+    def deconstruct
+      [value]
+    end
   end
 end

data/lib/fear/success_pattern_match.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Fear
+  # @api private
+  class SuccessPatternMatch < Fear::TryPatternMatch
+    # @param conditions [<#==>]
+    # @return [Fear::TryPatternMatch]
+    def failure(*_conditions)
+      self
+    end
+  end
+end

data/lib/fear/try.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # The +Try+ represents a computation that may either result
   # in an exception, or return a successfully computed value. Instances of +Try+,
@@ -11,15 +13,23 @@ module Fear
   # @example
   #   include Fear::Try::Mixin
   #
-  #   dividend = Try { Integer(params[:dividend]) }
-  #   divisor = Try { Integer(params[:divisor]) }
+  #   dividend = Fear.try { Integer(params[:dividend]) }
+  #   divisor = Fear.try { Integer(params[:divisor]) }
   #   problem = dividend.flat_map { |x| divisor.map { |y| x / y } }
   #
-  #   if problem.success?
-  #     puts "Result of #{dividend.get} / #{divisor.get} is: #{problem.get}"
-  #   else
-  #     puts "You must've divided by zero or entered something wrong. Try again"
-  #     puts "Info from the exception: #{problem.exception.message}"
+  #   problem.match |m|
+  #     m.success do |result|
+  #       puts "Result of #{dividend.get} / #{divisor.get} is: #{result}"
+  #     end
+  #
+  #     m.failure(ZeroDivisionError) do
+  #       puts "Division by zero is not allowed"
+  #     end
+  #
+  #     m.failure do |exception|
+  #       puts "You entered something wrong. Try again"
+  #       puts "Info from the exception: #{exception.message}"
+  #     end
   #   end
   #
   # An important property of +Try+ shown in the above example is its
@@ -45,13 +55,13 @@ module Fear
   #     @yieldreturn [any]
   #     @return [any]
   #     @example
-  #       Success(42).get_or_else { 24/2 }                #=> 42
-  #       Failure(ArgumentError.new).get_or_else { 24/2 } #=> 12
+  #       Fear.success(42).get_or_else { 24/2 }                #=> 42
+  #       Fear.failure(ArgumentError.new).get_or_else { 24/2 } #=> 12
   #   @overload get_or_else(default)
   #     @return [any]
   #     @example
-  #       Success(42).get_or_else(12)                #=> 42
-  #       Failure(ArgumentError.new).get_or_else(12) #=> 12
+  #       Fear.success(42).get_or_else(12)                #=> 42
+  #       Fear.failure(ArgumentError.new).get_or_else(12) #=> 12
   #
   # @!method include?(other_value)
   #   Returns +true+ if it has an element that is equal
@@ -59,9 +69,9 @@ module Fear
   #   @param [any]
   #   @return [Boolean]
   #   @example
-  #     Success(17).include?(17)                #=> true
-  #     Success(17).include?(7)                 #=> false
-  #     Failure(ArgumentError.new).include?(17) #=> false
+  #     Fear.success(17).include?(17)                #=> true
+  #     Fear.success(17).include?(7)                 #=> false
+  #     Fear.failure(ArgumentError.new).include?(17) #=> false
   #
   # @!method each(&block)
   #   Performs the given block if this is a +Success+.
@@ -70,11 +80,11 @@ module Fear
   #   @yieldreturn [void]
   #   @return [Try] itself
   #   @example
-  #     Success(17).each do |value|
+  #     Fear.success(17).each do |value|
   #       puts value
   #     end #=> prints 17
   #
-  #     Failure(ArgumentError.new).each do |value|
+  #     Fear.failure(ArgumentError.new).each do |value|
   #       puts value
   #     end #=> does nothing
   #
@@ -84,8 +94,8 @@ module Fear
   #   @yieldparam [any] value
   #   @yieldreturn [any]
   #   @example
-  #     Success(42).map { |v| v/2 }                 #=> Success(21)
-  #     Failure(ArgumentError.new).map { |v| v/2 }  #=> Failure(ArgumentError.new)
+  #     Fear.success(42).map { |v| v/2 }                 #=> Fear.success(21)
+  #     Fear.failure(ArgumentError.new).map { |v| v/2 }  #=> Fear.failure(ArgumentError.new)
   #
   # @!method flat_map(&block)
   #   Returns the given block applied to the value from this +Success+
@@ -94,26 +104,18 @@ module Fear
   #   @yieldreturn [Try]
   #   @return [Try]
   #   @example
-  #     Success(42).flat_map { |v| Success(v/2) }
-  #       #=> Success(21)
-  #     Failure(ArgumentError.new).flat_map { |v| Success(v/2) }
-  #       #=> Failure(ArgumentError.new)
-  #
-  # @!method to_a
-  #   Returns an +Array+ containing the +Success+ value or an
-  #   empty +Array+ if this is a +Failure+.
-  #   @return [Array]
-  #   @example
-  #     Success(42).to_a                 #=> [21]
-  #     Failure(ArgumentError.new).to_a  #=> []
+  #     Fear.success(42).flat_map { |v| Fear.success(v/2) }
+  #       #=> Fear.success(21)
+  #     Fear.failure(ArgumentError.new).flat_map { |v| Fear.success(v/2) }
+  #       #=> Fear.failure(ArgumentError.new)
   #
   # @!method to_option
   #   Returns an +Some+ containing the +Success+ value or a +None+ if
   #   this is a +Failure+.
   #   @return [Option]
   #   @example
-  #     Success(42).to_option                 #=> Some(21)
-  #     Failure(ArgumentError.new).to_option  #=> None()
+  #     Fear.success(42).to_option                 #=> Fear.some(21)
+  #     Fear.failure(ArgumentError.new).to_option  #=> Fear.none()
   #
   # @!method any?(&predicate)
   #   Returns +false+ if +Failure+ or returns the result of the
@@ -122,9 +124,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Boolean]
   #   @example
-  #     Success(12).any?( |v| v > 10)                #=> true
-  #     Success(7).any?( |v| v > 10)                 #=> false
-  #     Failure(ArgumentError.new).any?( |v| v > 10) #=> false
+  #     Fear.success(12).any?( |v| v > 10)                #=> true
+  #     Fear.success(7).any?( |v| v > 10)                 #=> false
+  #     Fear.failure(ArgumentError.new).any?( |v| v > 10) #=> false
   #
   # ---
   #
@@ -141,26 +143,27 @@ module Fear
   #   if this is a +Failure+.
   #   @return [any]
   #   @example
-  #     Success(42).get                 #=> 42
-  #     Failure(ArgumentError.new).get  #=> ArgumentError: ArgumentError
+  #     Fear.success(42).get                 #=> 42
+  #     Fear.failure(ArgumentError.new).get  #=> ArgumentError: ArgumentError
   #
   # @!method or_else(&alternative)
   #   Returns this +Try+ if it's a +Success+ or the given alternative if this is a +Failure+.
   #   @return [Try]
   #   @example
-  #     Success(42).or_else { Success(-1) }                 #=> Success(42)
-  #     Failure(ArgumentError.new).or_else { Success(-1) }  #=> Success(-1)
-  #     Failure(ArgumentError.new).or_else { Try { 1/0 } }  #=> Failure(ZeroDivisionError.new('divided by 0'))
+  #     Fear.success(42).or_else { Fear.success(-1) }                 #=> Fear.success(42)
+  #     Fear.failure(ArgumentError.new).or_else { Fear.success(-1) }  #=> Fear.success(-1)
+  #     Fear.failure(ArgumentError.new).or_else { Fear.try { 1/0 } }
+  #       #=> Fear.failure(ZeroDivisionError.new('divided by 0'))
   #
   # @!method flatten
   #   Transforms a nested +Try+, ie, a +Success+ of +Success+,
   #   into an un-nested +Try+, ie, a +Success+.
   #   @return [Try]
   #   @example
-  #     Success(42).flatten                         #=> Success(42)
-  #     Success(Success(42)).flatten                #=> Success(42)
-  #     Success(Failure(ArgumentError.new)).flatten #=> Failure(ArgumentError.new)
-  #     Failure(ArgumentError.new).flatten { -1 }   #=> Failure(ArgumentError.new)
+  #     Fear.success(42).flatten                         #=> Fear.success(42)
+  #     Fear.success(Fear.success(42)).flatten                #=> Fear.success(42)
+  #     Fear.success(Fear.failure(ArgumentError.new)).flatten #=> Fear.failure(ArgumentError.new)
+  #     Fear.failure(ArgumentError.new).flatten { -1 }   #=> Fear.failure(ArgumentError.new)
   #
   # @!method select(&predicate)
   #   Converts this to a +Failure+ if the predicate is not satisfied.
@@ -168,47 +171,80 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Try]
   #   @example
-  #     Success(42).select { |v| v > 40 }
-  #       #=> Success(21)
-  #     Success(42).select { |v| v < 40 }
-  #       #=> Failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
-  #     Failure(ArgumentError.new).select { |v| v < 40 }
-  #       #=> Failure(ArgumentError.new)
+  #     Fear.success(42).select { |v| v > 40 }
+  #       #=> Fear.success(21)
+  #     Fear.success(42).select { |v| v < 40 }
+  #       #=> Fear.failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
+  #     Fear.failure(ArgumentError.new).select { |v| v < 40 }
+  #       #=> Fear.failure(ArgumentError.new)
   #
   # @!method recover_with(&block)
   #   Applies the given block to exception. This is like +flat_map+
   #   for the exception.
-  #   @yieldparam [Exception] exception
-  #   @yieldreturn [Try]
-  #   @return [Try]
+  #   @yieldparam [Fear::PatternMatch] matcher
+  #   @yieldreturn [Fear::Try]
+  #   @return [Fear::Try]
   #   @example
-  #     Success(42).recover_with { |e| Success(e.massage) }
-  #       #=> Success(42)
-  #     Failure(ArgumentError.new).recover_with { |e| Success(e.massage) }
-  #       #=> Success('ArgumentError')
-  #     Failure(ArgumentError.new).recover_with { |e| fail }
-  #       #=> Failure(RuntimeError)
+  #     Fear.success(42).recover_with do |m|
+  #       m.case(ZeroDivisionError) { Fear.success(0) }
+  #     end #=> Fear.success(42)
+  #
+  #     Fear.failure(ArgumentError.new).recover_with do |m|
+  #       m.case(ZeroDivisionError) { Fear.success(0) }
+  #       m.case(ArgumentError) { |error| Fear.success(error.class.name) }
+  #     end #=> Fear.success('ArgumentError')
+  #
+  #     # If the block raises error, this new error returned as an result
+  #
+  #     Fear.failure(ArgumentError.new).recover_with do |m|
+  #       raise
+  #     end #=> Fear.failure(RuntimeError)
   #
   # @!method recover(&block)
   #   Applies the given block to exception. This is like +map+ for the exception.
-  #   @yieldparam [Exception] exception
+  #   @yieldparam [Fear::PatternMatch] matcher
   #   @yieldreturn [any]
-  #   @return [Try]
+  #   @return [Fear::Try]
   #   @example #recover
-  #     Success(42).recover { |e| e.massage }
-  #       #=> Success(42)
-  #     Failure(ArgumentError.new).recover { |e| e.massage }
-  #       #=> Success('ArgumentError')
-  #     Failure(ArgumentError.new).recover { |e| fail }
-  #       #=> Failure(RuntimeError)
+  #     Fear.success(42).recover do |m|
+  #       m.case(&:message)
+  #     end #=> Fear.success(42)
+  #
+  #     Fear.failure(ArgumentError.new).recover do |m|
+  #       m.case(ZeroDivisionError) { 0 }
+  #       m.case(&:message)
+  #     end #=> Fear.success('ArgumentError')
+  #
+  #     # If the block raises error, this new error returned as an result
+  #
+  #     Fear.failure(ArgumentError.new).recover do |m|
+  #       raise
+  #     end #=> Fear.failure(RuntimeError)
   #
   # @!method to_either
   #   Returns +Left+ with exception if this is a +Failure+, otherwise
   #   returns +Right+ with +Success+ value.
   #   @return [Right<any>, Left<StandardError>]
   #   @example
-  #     Success(42).to_either                #=> Right(42)
-  #     Failure(ArgumentError.new).to_either #=> Left(ArgumentError.new)
+  #     Fear.success(42).to_either                #=> Fear.right(42)
+  #     Fear.failure(ArgumentError.new).to_either #=> Fear.left(ArgumentError.new)
+  #
+  # @!method match(&matcher)
+  #   Pattern match against this +Try+
+  #   @yield matcher [Fear::TryPatternMatch]
+  #   @example
+  #     Fear.try { ... }.match do |m|
+  #       m.success(Integer) do |x|
+  #        x * 2
+  #       end
+  #
+  #       m.success(String) do |x|
+  #         x.to_i * 2
+  #       end
+  #
+  #       m.failure(ZeroDivisionError) { 'not allowed to divide by 0' }
+  #       m.else { 'something unexpected' }
+  #     end
   #
   # @author based on Twitter's original implementation.
   # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/util/Try.scala
@@ -224,38 +260,59 @@ module Fear
       Success
     end
 
+    class << self
+      # Build pattern matcher to be used later, despite off
+      # +Try#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 =
+      #     Try.matcher do |m|
+      #       m.success(Integer, ->(x) { x > 2 }) { |x| x * 2 }
+      #       m.success(String) { |x| x.to_i * 2 }
+      #       m.failure(ActiveRecord::RecordNotFound) { :err }
+      #       m.else { 'error '}
+      #     end
+      #   matcher.call(try)
+      #
+      # @yieldparam [Fear::TryPatternMatch]
+      # @return [Fear::PartialFunction]
+      def matcher(&matcher)
+        TryPatternMatch.new(&matcher)
+      end
+    end
+
     # Include this mixin to access convenient factory methods.
     # @example
     #   include Fear::Try::Mixin
     #
-    #   Try { 4/2 } #=> #<Fear::Success value=2>
-    #   Try { 4/0 } #=> #<Fear::Failure value=#<ZeroDivisionError: divided by 0>>
-    #   Success(2)  #=> #<Fear::Success value=2>
+    #   Fear.try { 4/2 } #=> #<Fear::Success value=2>
+    #   Fear.try { 4/0 } #=> #<Fear::Failure exception=#<ZeroDivisionError: divided by 0>>
+    #   Fear.success(2)  #=> #<Fear::Success value=2>
     #
     module Mixin
       # Constructs a +Try+ using the block. This
-      # method will ensure any non-fatal exception )is caught and a
+      # method ensures any non-fatal exception is caught and a
       # +Failure+ object is returned.
       # @return [Try]
       #
-      def Try
-        Success.new(yield)
-      rescue => error
-        Failure.new(error)
+      def Try(&block)
+        Fear.try(&block)
       end
 
       # @param exception [StandardError]
       # @return [Failure]
       #
       def Failure(exception)
-        Failure.new(exception)
+        Fear.failure(exception)
       end
 
       # @param value [any]
       # @return [Success]
       #
       def Success(value)
-        Success.new(value)
+        Fear.success(value)
       end
     end
   end

data/lib/fear/try_api.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fear
+  module TryApi
+    # Constructs a +Try+ using the block. This
+    # method ensures any non-fatal exception is caught and a
+    # +Failure+ object is returned.
+    # @return [Fear::Try]
+    # @example
+    #   Fear.try { 4/0 } #=> #<Fear::Failure exception=#<ZeroDivisionError: divided by 0>>
+    #   Fear.try { 4/2 } #=> #<Fear::Success value=2>
+    #
+    def try
+      success(yield)
+    rescue StandardError => error
+      failure(error)
+    end
+
+    # @param exception [StandardError]
+    # @return [Fear::Failure]
+    #
+    def failure(exception)
+      Fear::Failure.new(exception)
+    end
+
+    # @param value [any]
+    # @return [Fear::Success]
+    #
+    def success(value)
+      Fear::Success.new(value)
+    end
+  end
+end