fear 0.10.0 → 0.11.0

data/lib/fear/option.rb

@@ -11,12 +11,9 @@ module Fear
   # having to check for the existence of a value.
   #
   # @example A less-idiomatic way to use +Option+ values is via pattern matching
-  #   name = Option(params[:name])
-  #   case name
-  #   when Some
-  #     puts name.strip.upcase
-  #   when None
-  #     puts 'No name value'
+  #   Option(params[:name]).match do |m|
+  #     m.some { |name| name.strip.upcase }
+  #     m.none { 'No name value' }
   #   end
   #
   # @example or manually checking for non emptiness
@@ -35,20 +32,20 @@ module Fear
   #     @return [any]
   #     @example
   #       Some(42).get_or_else { 24/2 } #=> 42
-  #       None().get_or_else { 24/2 }   #=> 12
+  #       None.get_or_else { 24/2 }   #=> 12
   #   @overload get_or_else(default)
   #     @return [any]
   #     @example
   #       Some(42).get_or_else(12)  #=> 42
-  #       None().get_or_else(12)    #=> 12
+  #       None.get_or_else(12)    #=> 12
   #
   # @!method or_else(&alternative)
   #   Returns this +Some+ or the given alternative if this is a +None+.
   #   @return [Option]
   #   @example
   #     Some(42).or_else { Some(21) } #=> Some(42)
-  #     None().or_else { Some(21) }   #=> Some(21)
-  #     None().or_else { None() }     #=> None()
+  #     None.or_else { Some(21) }   #=> Some(21)
+  #     None.or_else { None }     #=> None
   #
   # @!method include?(other_value)
   #   Returns +true+ if it has an element that is equal
@@ -58,7 +55,7 @@ module Fear
   #   @example
   #     Some(17).include?(17) #=> true
   #     Some(17).include?(7)  #=> false
-  #     None().include?(17)   #=> false
+  #     None.include?(17)   #=> false
   #
   # @!method each(&block)
   #   Performs the given block if this is a +Some+.
@@ -70,7 +67,7 @@ module Fear
   #       puts value
   #     end #=> prints 17
   #
-  #     None().each do |value|
+  #     None.each do |value|
   #       puts value
   #     end #=> does nothing
   #
@@ -81,7 +78,7 @@ module Fear
   #   @yieldreturn [any]
   #   @example
   #     Some(42).map { |v| v/2 } #=> Some(21)
-  #     None().map { |v| v/2 }   #=> None()
+  #     None.map { |v| v/2 }   #=> None
   #
   # @!method flat_map(&block)
   #   Returns the given block applied to the value from this +Some+
@@ -91,15 +88,7 @@ module Fear
   #   @return [Option]
   #   @example
   #     Some(42).flat_map { |v| Some(v/2) }   #=> Some(21)
-  #     None().flat_map { |v| Some(v/2) }     #=> None()
-  #
-  # @!method to_a
-  #   Returns an +Array+ containing the +Some+ value or an
-  #   empty +Array+ if this is a +None+
-  #   @return [Array]
-  #   @example
-  #     Some(42).to_a #=> [21]
-  #     None().to_a   #=> []
+  #     None.flat_map { |v| Some(v/2) }     #=> None
   #
   # @!method any?(&predicate)
   #   Returns +false+ if +None+ or returns the result of the
@@ -110,7 +99,7 @@ module Fear
   #   @example
   #     Some(12).any?( |v| v > 10)  #=> true
   #     Some(7).any?( |v| v > 10)   #=> false
-  #     None().any?( |v| v > 10)    #=> false
+  #     None.any?( |v| v > 10)    #=> false
   #
   # @!method select(&predicate)
   #   Returns self if it is nonempty and applying the predicate to this
@@ -120,8 +109,8 @@ module Fear
   #   @return [Option]
   #   @example
   #     Some(42).select { |v| v > 40 } #=> Success(21)
-  #     Some(42).select { |v| v < 40 } #=> None()
-  #     None().select { |v| v < 40 }   #=> None()
+  #     Some(42).select { |v| v < 40 } #=> None
+  #     None.select { |v| v < 40 }   #=> None
   #
   # @!method reject(&predicate)
   #   Returns +Some+ if applying the predicate to this
@@ -132,7 +121,7 @@ module Fear
   #   @example
   #     Some(42).reject { |v| v > 40 } #=> None
   #     Some(42).reject { |v| v < 40 } #=> Some(42)
-  #     None().reject { |v| v < 40 }   #=> None
+  #     None.reject { |v| v < 40 }   #=> None
   #
   # @!method get
   #   @return [any] the +Option+'s value.
@@ -143,14 +132,31 @@ module Fear
   #   @return [Boolean]
   #   @example
   #     Some(42).empty? #=> false
-  #     None().empty?   #=> true
+  #     None.empty?   #=> true
+  #
+  # @!method match(&matcher)
+  #   Pattern match against this +Option+
+  #   @yield matcher [Fear::OptionPatternMatch]
+  #   @example
+  #     Option(val).match do |m|
+  #       m.some(Integer) do |x|
+  #        x * 2
+  #       end
+  #
+  #       m.some(String) do |x|
+  #         x.to_i * 2
+  #       end
+  #
+  #       m.none { 'NaN' }
+  #       m.else { 'error '}
+  #     end
   #
   # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/Option.scala
   #
   module Option
     # @private
     def left_class
-      None
+      NoneClass
     end
 
     # @private
@@ -158,6 +164,29 @@ module Fear
       Some
     end
 
+    class << self
+      # Build pattern matcher to be used later, despite off
+      # +Option#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 =
+      #     Option.matcher do |m|
+      #       m.some(Integer) { |x| x * 2 }
+      #       m.some(String) { |x| x.to_i * 2 }
+      #       m.none { 'NaN' }
+      #       m.else { 'error '}
+      #     end
+      #   matcher.call(Some(42))
+      #
+      # @yieldparam [OptionPatternMatch]
+      # @return [Fear::PartialFunction]
+      def matcher(&matcher)
+        OptionPatternMatch.new(&matcher)
+      end
+    end
+
     # Include this mixin to access convenient factory methods.
     # @example
     #   include Fear::Option::Mixin
@@ -165,17 +194,22 @@ module Fear
     #   Option(17)  #=> #<Fear::Some value=17>
     #   Option(nil) #=> #<Fear::None>
     #   Some(17)    #=> #<Fear::Some value=17>
-    #   None()      #=> #<Fear::None>
+    #   None        #=> #<Fear::None>
     #
     module Mixin
+      None = Fear::None
+
       # An +Option+ factory which creates +Some+ if the argument is
       # not +nil+, and +None+ if it is +nil+.
       # @param value [any]
       # @return [Some, None]
       #
+      # @example
+      #   Option(v)
+      #
       def Option(value)
         if value.nil?
-          None()
+          None
         else
           Some(value)
         end
@@ -183,7 +217,7 @@ module Fear
 
       # @return [None]
       def None
-        None.new
+        Fear::None
       end
 
       # @param value [any] except nil

data/lib/fear/option_pattern_match.rb

@@ -0,0 +1,45 @@
+module Fear
+  # Option pattern matcher
+  #
+  # @example
+  #   pattern_match =
+  #     OptionPatternMatch.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
+  #    OptionPatternMatch.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 OptionPatternMatch < Fear::PatternMatch
+    GET_METHOD = :get.to_proc
+
+    # Match against Some
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::OptionPatternMatch]
+    def some(*conditions, &effect)
+      branch = Fear.case(Fear::Some, &GET_METHOD).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+
+    # Match against None
+    #
+    # @param effect [Proc]
+    # @return [Fear::OptionPatternMatch]
+    def none(&effect)
+      branch = Fear.case(Fear::None, &effect)
+      or_else(branch)
+    end
+  end
+end

data/lib/fear/partial_function/and_then.rb

@@ -0,0 +1,48 @@
+module Fear
+  module PartialFunction
+    # Composite function produced by +PartialFunction#and_then+ method
+    # @api private
+    class AndThen
+      include PartialFunction
+
+      # @param partial_function [Fear::PartialFunction]
+      # @param function [Proc]
+      def initialize(partial_function, &function)
+        @partial_function = partial_function
+        @function = function
+      end
+      # @!attribute partial_function
+      #   @return [Fear::PartialFunction]
+      # @!attribute function
+      #   @return [Proc]
+      attr_reader :partial_function
+      attr_reader :function
+      private :partial_function
+      private :function
+
+      # @param arg [any]
+      # @return [any ]
+      def call(arg)
+        function.call(partial_function.call(arg))
+      end
+
+      # @param arg [any]
+      # @return [Boolean]
+      def defined_at?(arg)
+        partial_function.defined_at?(arg)
+      end
+
+      # @param arg [any]
+      # @yield [arg]
+      # @return [any]
+      def call_or_else(arg)
+        result = partial_function.call_or_else(arg) do
+          return yield(arg)
+        end
+        function.call(result)
+      end
+    end
+
+    private_constant :AndThen
+  end
+end

data/lib/fear/partial_function/any.rb

@@ -0,0 +1,26 @@
+module Fear
+  module PartialFunction
+    # Any is an object which is always truthy
+    # @api private
+    class Any
+      class << self
+        # @param _other [any]
+        # @return [true]
+        def ===(_other)
+          true
+        end
+
+        # @param _other [any]
+        # @return [true]
+        def ==(_other)
+          true
+        end
+
+        # @return [Proc]
+        def to_proc
+          proc { true }
+        end
+      end
+    end
+  end
+end

data/lib/fear/partial_function/combined.rb

@@ -0,0 +1,51 @@
+module Fear
+  module PartialFunction
+    # Composite function produced by +PartialFunction#and_then+ method
+    # @api private
+    class Combined
+      include PartialFunction
+
+      # @param f1 [Fear::PartialFunction]
+      # @param f2 [Fear::PartialFunction]
+      def initialize(f1, f2)
+        @f1 = f1
+        @f2 = f2
+      end
+      # @!attribute f1
+      #   @return [Fear::PartialFunction]
+      # @!attribute f2
+      #   @return [Fear::PartialFunction]
+      attr_reader :f1, :f2
+      private :f1
+      private :f2
+
+      # @param arg [any]
+      # @return [any ]
+      def call(arg)
+        f2.call(f1.call(arg))
+      end
+
+      alias === call
+      alias [] call
+
+      # @param arg [any]
+      # @yieldparam arg [any]
+      # @return [any]
+      def call_or_else(arg)
+        result = f1.call_or_else(arg) { return yield(arg) }
+        f2.call_or_else(result) { |_| return yield(arg) }
+      end
+
+      # @param arg [any]
+      # @return [Boolean]
+      def defined_at?(arg)
+        result = f1.call_or_else(arg) do
+          return false
+        end
+        f2.defined_at?(result)
+      end
+    end
+
+    private_constant :AndThen
+  end
+end

data/lib/fear/partial_function/empty.rb

@@ -0,0 +1,6 @@
+module Fear
+  module PartialFunction
+    EMPTY = Object.new.extend(EmptyPartialFunction)
+    EMPTY.freeze
+  end
+end

data/lib/fear/partial_function/guard/and.rb

@@ -0,0 +1,36 @@
+module Fear
+  module PartialFunction
+    class Guard
+      # @api private
+      class And < Guard
+        # @param c1 [Fear::PartialFunction::Guard]
+        # @param c2 [Fear::PartialFunction::Guard]
+        def initialize(c1, c2)
+          @c1 = c1
+          @c2 = c2
+        end
+        attr_reader :c1, :c2
+        private :c1
+        private :c2
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def and(other)
+          Guard::And.new(self, other)
+        end
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def or(other)
+          Guard::Or.new(self, other)
+        end
+
+        # @param arg [any]
+        # @return [Boolean]
+        def ===(arg)
+          (c1 === arg) && (c2 === arg)
+        end
+      end
+    end
+  end
+end

data/lib/fear/partial_function/guard/and3.rb

@@ -0,0 +1,39 @@
+module Fear
+  module PartialFunction
+    class Guard
+      # @api private
+      class And3 < Guard
+        # @param c1 [#===]
+        # @param c2 [#===]
+        # @param c3 [#===]
+        def initialize(c1, c2, c3)
+          @c1 = c1
+          @c2 = c2
+          @c3 = c3
+        end
+        attr_reader :c1, :c2, :c3
+        private :c1
+        private :c2
+        private :c3
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def and(other)
+          Guard::And.new(self, other)
+        end
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def or(other)
+          Guard::Or.new(self, other)
+        end
+
+        # @param arg [any]
+        # @return [Boolean]
+        def ===(arg)
+          (c1 === arg) && (c2 === arg) && (c3 === arg)
+        end
+      end
+    end
+  end
+end

data/lib/fear/partial_function/guard/or.rb

@@ -0,0 +1,36 @@
+module Fear
+  module PartialFunction
+    class Guard
+      # @api private
+      class Or < Guard
+        # @param c1 [Fear::PartialFunction::Guard]
+        # @param c2 [Fear::PartialFunction::Guard]
+        def initialize(c1, c2)
+          @c1 = c1
+          @c2 = c2
+        end
+        attr_reader :c1, :c2
+        private :c1
+        private :c2
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def and(other)
+          Guard::And.new(self, other)
+        end
+
+        # @param other [Fear::PartialFunction::Guard]
+        # @return [Fear::PartialFunction::Guard]
+        def or(other)
+          Guard::Or.new(self, other)
+        end
+
+        # @param arg [any]
+        # @return [Boolean]
+        def ===(arg)
+          (c1 === arg) || (c2 === arg)
+        end
+      end
+    end
+  end
+end

data/lib/fear/partial_function/guard.rb

@@ -0,0 +1,90 @@
+module Fear
+  module PartialFunction
+    # Guard represents PartialFunction guardian
+    #
+    # @api private
+    class Guard
+      autoload :And, 'fear/partial_function/guard/and'
+      autoload :And3, 'fear/partial_function/guard/and3'
+      autoload :Or, 'fear/partial_function/guard/or'
+
+      class << self
+        # Optimized version for combination of two guardians
+        # Two guarding is a very common situation. For example checking for Some, and checking
+        # a value withing contianer.
+        #
+        def and2(c1, c2)
+          Guard::And.new(
+            (c1.is_a?(Symbol) ? c1.to_proc : c1),
+            (c2.is_a?(Symbol) ? c2.to_proc : c2),
+          )
+        end
+
+        def and3(c1, c2, c3)
+          Guard::And3.new(
+            (c1.is_a?(Symbol) ? c1.to_proc : c1),
+            (c2.is_a?(Symbol) ? c2.to_proc : c2),
+            (c3.is_a?(Symbol) ? c3.to_proc : c3),
+          )
+        end
+
+        def and1(c)
+          c.is_a?(Symbol) ? c.to_proc : c
+        end
+
+        # @param conditions [<#===, Symbol>]
+        # @return [Fear::PartialFunction::Guard]
+        def and(conditions)
+          case conditions.size
+          when 1 then and1(*conditions)
+          when 2 then and2(*conditions)
+          when 3 then and3(*conditions)
+          when 0 then Any
+          else
+            head, *tail = conditions
+            tail.inject(new(head)) { |acc, condition| acc.and(new(condition)) }
+          end
+        end
+
+        # @param conditions [<#===, Symbol>]
+        # @return [Fear::PartialFunction::Guard]
+        def or(conditions)
+          return Any if conditions.empty?
+
+          head, *tail = conditions
+          tail.inject(new(head)) { |acc, condition| acc.or(new(condition)) }
+        end
+      end
+
+      # @param condition [<#===, Symbol>]
+      def initialize(condition)
+        @condition =
+          if condition.is_a?(Symbol)
+            condition.to_proc
+          else
+            condition
+          end
+      end
+      attr_reader :condition
+      private :condition
+
+      # @param other [Fear::PartialFunction::Guard]
+      # @return [Fear::PartialFunction::Guard]
+      def and(other)
+        Guard::And.new(condition, other)
+      end
+
+      # @param other [Fear::PartialFunction::Guard]
+      # @return [Fear::PartialFunction::Guard]
+      def or(other)
+        Guard::Or.new(condition, other)
+      end
+
+      # @param arg [any]
+      # @return [Boolean]
+      def ===(arg)
+        condition === arg
+      end
+    end
+  end
+end

data/lib/fear/partial_function/lifted.rb

@@ -0,0 +1,20 @@
+module Fear
+  module PartialFunction
+    # @api private
+    class Lifted
+      # @param pf [Fear::PartialFunction]
+      def initialize(pf)
+        @pf = pf
+      end
+      attr_reader :pf
+
+      # @param arg [any]
+      # @return [Fear::Option]
+      def call(arg)
+        Some.new(pf.call_or_else(arg) { return Fear::None })
+      end
+    end
+
+    private_constant :Lifted
+  end
+end

data/lib/fear/partial_function/or_else.rb

@@ -0,0 +1,62 @@
+module Fear
+  module PartialFunction
+    # Composite function produced by +PartialFunction#or_else+ method
+    # @api private
+    class OrElse
+      include PartialFunction
+
+      # @param f1 [Fear::PartialFunction]
+      # @param f2 [Fear::PartialFunction]
+      def initialize(f1, f2)
+        @f1 = f1
+        @f2 = f2
+      end
+      # @!attribute f1
+      #   @return [Fear::PartialFunction]
+      # @!attribute f2
+      #   @return [Fear::PartialFunction]
+      attr_reader :f1, :f2
+      private :f1
+      private :f2
+
+      # @param arg [any]
+      # @return [any]
+      def call(arg)
+        f1.call_or_else(arg, &f2)
+      end
+
+      alias === call
+      alias [] call
+
+      # @param other [Fear::PartialFunction]
+      # @return [Fear::PartialFunction]
+      def or_else(other)
+        OrElse.new(f1, f2.or_else(other))
+      end
+
+      # @see Fear::PartialFunction#and_then
+      def and_then(other = Utils::UNDEFINED, &block)
+        Utils.with_block_or_argument('Fear::PartialFunction::OrElse#and_then', other, block) do |fun|
+          OrElse.new(f1.and_then(&fun), f2.and_then(&fun))
+        end
+      end
+
+      # @param arg [any]
+      # @return [Boolean]
+      def defined_at?(arg)
+        f1.defined_at?(arg) || f2.defined_at?(arg)
+      end
+
+      # @param arg [any]
+      # @param fallback [Proc]
+      # @return [any]
+      def call_or_else(arg, &fallback)
+        f1.call_or_else(arg) do
+          return f2.call_or_else(arg, &fallback)
+        end
+      end
+    end
+
+    private_constant :OrElse
+  end
+end