fear 0.11.0 → 1.0.0

data/lib/fear/partial_function/lifted.rb

@@ -7,6 +7,7 @@ module Fear
         @pf = pf
       end
       attr_reader :pf
+      private :pf
 
       # @param arg [any]
       # @return [Fear::Option]

data/lib/fear/partial_function_class.rb

@@ -3,6 +3,16 @@ module Fear
   class PartialFunctionClass
     include PartialFunction
 
+    # @param condition [#call] describes the domain of partial function
+    # @param function [Proc] function definition
+    def initialize(condition, &function)
+      @condition = condition
+      @function = function
+    end
+    attr_reader :condition, :function
+    private :condition
+    private :function
+
     # @param arg [any]
     # @return [any] Calls this partial function with the given argument when it
     #   is contained in the function domain.

data/lib/fear/pattern_match.rb

@@ -93,6 +93,16 @@ module Fear
       or_else(Fear.case(*guards, &effect))
     end
 
+    # @param pattern [String]
+    # @param guards [<#===>]
+    # @param effect [Proc]
+    # @return [Fear::PartialFunction]
+    # @see #case for details
+    # @see Fear.xcase for details
+    def xcase(pattern, *guards, &effect)
+      or_else(Fear.xcase(pattern, *guards, &effect))
+    end
+
     # @see Fear::PartialFunction#or_else
     def or_else(other)
       self.result = result.or_else(other)

data/lib/fear/pattern_matching_api.rb

@@ -34,16 +34,19 @@ module Fear
     #
     #     m.case(20..40) { |m| "#{m} is within range" }
     #     m.case(->(x) { x > 10}) { |m| "#{m} is greater than 10" }
+    #     m.case(:even?.to_proc) { |x| "#{x} is even" }
+    #     m.case(:odd?.to_proc) { |x| "#{x} is odd" }
     #
-    # If you pass a Symbol, it will be converted to proc using +#to_proc+ method
+    # It's also possible to pass several guardians. All should match to pass
     #
-    #     m.case(:even?) { |x| "#{x} is even" }
-    #     m.case(:odd?) { |x| "#{x} is odd" }
+    #     m.case(Integer, :even?.to_proc) { |x| ... }
+    #     m.case(Integer, :odd?.to_proc) { |x| ... }
     #
-    # It's also possible to pass several guardians. All should match to pass
+    # If you want to perform pattern destruction, use +#xcase+ method
     #
-    #     m.case(Integer, :even?) { |x| ... }
-    #     m.case(Integer, :odd?) { |x| ... }
+    #     m.xcase('Date(year, 12, 31)') { |year:| "Last day of the year #{year}" }
+    #
+    # The pattern above ensures that it's 31 of December and extracts year to block named parameter
     #
     # Since matcher returns +Fear::PartialFunction+, you can combine matchers using
     # partial function API:
@@ -59,7 +62,7 @@ module Fear
     #
     #     response = failures.or_else(success)
     #
-    # @yieldparam matcher [Fear::PartialFunction]
+    # @yieldparam matcher [Fear::PatternMatch]
     # @return [Fear::PartialFunction]
     # @see Fear::OptionPatternMatch for example of custom matcher
     def matcher(&block)
@@ -70,8 +73,8 @@ module Fear
     #
     # @example
     #   Fear.match(42) do |m|
-    #     m.case(Integer, :even?) { |n| "#{n} is even number" }
-    #     m.case(Integer, :odd?) { |n| "#{n} is odd number" }
+    #     m.case(Integer, :even?.to_proc) { |n| "#{n} is even number" }
+    #     m.case(Integer, :odd?.to_proc) { |n| "#{n} is odd number" }
     #     m.case(Strings) { |n| "#{n} is a string" }
     #     m.else { 'unknown' }
     #   end #=> "42 is even number"
@@ -91,7 +94,7 @@ module Fear
     #   pf.defined_at?('Foo') #=> false
     #
     # @example multiple guards combined using logical "and"
-    #   pf = Fear.case(Integer, :even?) { |x| x / 2 }
+    #   pf = Fear.case(Integer, :even?.to_proc) { |x| x / 2 }
     #   pf.defined_at?(4) #=> true
     #   pf.defined_at?(3) #=> false
     #
@@ -100,11 +103,32 @@ module Fear
     # @example
     #   Fear.case(Qo[age: 20..30]) { |_| 'old enough' }
     #
-    # @param guards [<#===, symbol>]
+    # @param guards [<#===>]
     # @param function [Proc]
     # @return [Fear::PartialFunction]
     def case(*guards, &function)
       PartialFunction.and(*guards, &function)
     end
+
+    # Creates partial function defined on domain described with guard
+    # and perform pattern extraction.
+    #
+    # @param pattern [String] pattern to match against
+    # @param guards [<#===>] other guards against extracted pattern
+    # @yieldparam hash [{Symbol => any}]
+    # @return [Fear::PartialFunction]
+    #
+    # @example
+    #   pf = Fear.xcase('['ok', Some(body)]') { |body:| ...  }
+    #   pf.defined_at?(['ok', Fear.some(body)]) #=> true
+    #   pf.defined_at?(['err', Fear.none]) #=> false
+    #
+    # @example pattern and guards. It matches against non-empty body
+    #
+    #   pf = Fear.xcase('['ok', Some(body)]', ->(body:) { !body.empty? }) { }
+    #
+    def xcase(pattern, *guards, &function)
+      Fear[pattern].and_then(self.case(*guards, &function))
+    end
   end
 end

data/lib/fear/promise.rb

@@ -0,0 +1,87 @@
+module Fear
+  # @api private
+  class Promise < Concurrent::IVar
+    # @param options [Hash] options passed to underlying +Concurrent::Future+
+    def initialize(options = {})
+      super()
+      @options = options
+      @promise = Concurrent::Promise.new(options) do
+        Fear.try { value }.flatten
+      end
+    end
+    attr_reader :promise, :options
+    private :promise
+    private :options
+
+    def completed?
+      complete?
+    end
+
+    # @return [Fear::Future]
+    def to_future
+      Future.new(promise, options)
+    end
+
+    # Complete this promise with successful result
+    # @param value [any]
+    # @return [Boolean]
+    # @see #complete
+    def success(value)
+      complete(Fear.success(value))
+    end
+
+    # Complete this promise with failure
+    # @param value [any]
+    # @return [self]
+    # @raise [IllegalStateException]
+    # @see #complete!
+    def success!(value)
+      complete!(Fear.success(value))
+    end
+
+    # Complete this promise with failure
+    # @param error [StandardError]
+    # @return [Boolean]
+    # @see #complete
+    def failure(error)
+      complete(Fear.failure(error))
+    end
+
+    # Complete this promise with failure
+    # @param error [StandardError]
+    # @return [self]
+    # @raise [IllegalStateException]
+    # @see #complete!
+    def failure!(error)
+      complete!(Fear.failure(error))
+    end
+
+    # Complete this promise with result
+    # @param result [Fear::Try]
+    # @return [self]
+    # @raise [IllegalStateException] if promise already completed
+    def complete!(result)
+      if complete(result)
+        self
+      else
+        raise IllegalStateException, 'Promise already completed.'
+      end
+    end
+
+    # Complete this promise with result
+    # @param result [Fear::Try]
+    # @return [Boolean] If the promise has already been completed returns
+    #   `false`, or `true` otherwise.
+    # @raise [IllegalStateException] if promise already completed
+    #
+    def complete(result)
+      if completed?
+        false
+      else
+        set result
+        promise.execute
+        true
+      end
+    end
+  end
+end

data/lib/fear/right.rb

@@ -4,6 +4,14 @@ module Fear
     include RightBiased::Right
     include RightPatternMatch.mixin
 
+    EXTRACTOR = proc do |either|
+      if Fear::Right === either
+        Fear.some([either.right_value])
+      else
+        Fear.none
+      end
+    end
+
     # @api private
     def right_value
       value

data/lib/fear/some.rb

@@ -1,15 +1,20 @@
 module Fear
   class Some
     include Option
-    include Dry::Equalizer(:get)
     include RightBiased::Right
     include SomePatternMatch.mixin
 
+    EXTRACTOR = proc do |option|
+      if Fear::Some === option
+        Fear.some([option.get])
+      else
+        Fear.none
+      end
+    end
+
     attr_reader :value
     protected :value
 
-    # FIXME: nice inspect
-
     def initialize(value)
       @value = value
     end
@@ -46,5 +51,19 @@ module Fear
         self
       end
     end
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Some) && get == other.get
+    end
+
+    # @return [String]
+    def inspect
+      "#<Fear::Some get=#{value.inspect}>"
+    end
+
+    # @return [String]
+    alias to_s inspect
   end
 end

data/lib/fear/success.rb

@@ -1,10 +1,17 @@
 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
+
     attr_reader :value
     protected :value
 
@@ -83,5 +90,19 @@ 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
   end
 end

data/lib/fear/try.rb

@@ -11,8 +11,8 @@ 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 } }
   #
   #   problem.match |m|
@@ -53,13 +53,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
@@ -67,9 +67,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+.
@@ -78,11 +78,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
   #
@@ -92,8 +92,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+
@@ -102,18 +102,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)
+  #     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 +122,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 +141,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,53 +169,69 @@ 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| raise }
-  #       #=> 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| raise }
-  #       #=> 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
-  #     Try { ... }.match do |m|
+  #     Fear.try { ... }.match do |m|
   #       m.success(Integer) do |x|
   #        x * 2
   #       end
@@ -268,34 +285,32 @@ module Fear
     # @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 StandardError => 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