fear 0.9.0 → 1.2.0

data/lib/fear/future_api.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fear
+  # rubocop: disable Layout/LineLength
+  module FutureApi
+    # Asynchronously evaluates the block
+    # @param options [Hash] options will be passed directly to underlying +Concurrent::Promise+
+    #   @see https://ruby-concurrency.github.io/concurrent-ruby/1.1.5/Concurrent/Promise.html#constructor_details Constructor Details
+    # @return [Fear::Future]
+    #
+    # @example
+    #   require 'open-uri'
+    #   f = Fear.future(executor: :io) { open('http://example.com') }
+    #   f.map(&:read).each { |body| puts body }
+    #
+    def future(options = {}, &block)
+      Future.new(options, &block)
+    end
+  end
+  # rubocop: enable Layout/LineLength
+end

data/lib/fear/left.rb

@@ -1,7 +1,24 @@
+# frozen_string_literal: true
+
 module Fear
   class Left
     include Either
     include RightBiased::Left
+    include LeftPatternMatch.mixin
+
+    EXTRACTOR = proc do |either|
+      if Fear::Left === either
+        Fear.some([either.left_value])
+      else
+        Fear.none
+      end
+    end
+    public_constant :EXTRACTOR
+
+    # @api private
+    def left_value
+      value
+    end
 
     # @return [false]
     def right?
@@ -37,8 +54,8 @@ module Fear
 
     # @param reduce_left [Proc]
     # @return [any]
-    def reduce(reduce_left, _)
-      reduce_left.call(value)
+    def reduce(reduce_left, _reduce_right)
+      reduce_left.(value)
     end
 
     # @return [self]

data/lib/fear/left_pattern_match.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+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,24 @@
+# frozen_string_literal: true
+
 module Fear
-  class None
+  # @api private
+  class NoneClass
     include Option
-    include Dry::Equalizer()
     include RightBiased::Left
+    include NonePatternMatch.mixin
+
+    EXTRACTOR = proc do |option|
+      if Fear::None === option
+        Fear.some([])
+      else
+        Fear.none
+      end
+    end
+    public_constant :EXTRACTOR
 
     # @raise [NoSuchElementError]
     def get
-      fail NoSuchElementError
+      raise NoSuchElementError
     end
 
     # @return [nil]
@@ -28,5 +40,57 @@ module Fear
     def reject(*)
       self
     end
+
+    # @return [String]
+    def inspect
+      "#<Fear::NoneClass>"
+    end
+
+    # @return [String]
+    alias to_s inspect
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(NoneClass)
+    end
+
+    # @param other
+    # @return [Boolean]
+    def ===(other)
+      self == other
+    end
+
+    # @param other [Fear::Option]
+    # @return [Fear::Option]
+    def zip(other)
+      if other.is_a?(Option)
+        Fear.none
+      else
+        raise TypeError, "can't zip with #{other.class}"
+      end
+    end
+
+    # @return [RightBiased::Left]
+    def filter_map
+      self
+    end
+  end
+
+  private_constant(:NoneClass)
+
+  # The only instance of NoneClass
+  # @api private
+  None = NoneClass.new.freeze
+  public_constant :None
+
+  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,14 @@
+# frozen_string_literal: true
+
+module Fear
+  # @api private
+  class NonePatternMatch < OptionPatternMatch
+    # @param conditions [<#==>]
+    # @return [Fear::OptionPatternMatch]
+    def some(*_conditions)
+      self
+    end
+  end
+
+  private_constant :NonePatternMatch
+end

data/lib/fear/option.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Fear
   # Represents optional values. Instances of +Option+
   # are either an instance of +Some+ or the object +None+.
   #
   # @example The most idiomatic way to use an +Option+ instance is to treat it as a collection
-  #   name = Option(params[:name])
+  #   name = Fear.option(params[:name])
   #   upper = name.map(&:strip).select { |n| n.length != 0 }.map(&:upcase)
   #   puts upper.get_or_else('')
   #
@@ -11,16 +13,13 @@ 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'
+  #   Fear.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
-  #   name = Option(params[:name])
+  #   name = Fear.option(params[:name])
   #   if name.empty?
   #     puts 'No name value'
   #   else
@@ -34,21 +33,21 @@ module Fear
   #     @yieldreturn [any]
   #     @return [any]
   #     @example
-  #       Some(42).get_or_else { 24/2 } #=> 42
-  #       None().get_or_else { 24/2 }   #=> 12
+  #       Fear.some(42).get_or_else { 24/2 } #=> 42
+  #       Fear.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
+  #       Fear.some(42).get_or_else(12)  #=> 42
+  #       Fear.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()
+  #     Fear.some(42).or_else { Fear.some(21) } #=> Fear.some(42)
+  #     Fear.none.or_else { Fear.some(21) }   #=> Fear.some(21)
+  #     Fear.none.or_else { None }     #=> None
   #
   # @!method include?(other_value)
   #   Returns +true+ if it has an element that is equal
@@ -56,9 +55,9 @@ module Fear
   #   @param [any]
   #   @return [Boolean]
   #   @example
-  #     Some(17).include?(17) #=> true
-  #     Some(17).include?(7)  #=> false
-  #     None().include?(17)   #=> false
+  #     Fear.some(17).include?(17) #=> true
+  #     Fear.some(17).include?(7)  #=> false
+  #     Fear.none.include?(17)   #=> false
   #
   # @!method each(&block)
   #   Performs the given block if this is a +Some+.
@@ -66,11 +65,11 @@ module Fear
   #   @yieldreturn [void]
   #   @return [Option] itself
   #   @example
-  #     Some(17).each do |value|
+  #     Fear.some(17).each do |value|
   #       puts value
   #     end #=> prints 17
   #
-  #     None().each do |value|
+  #     Fear.none.each do |value|
   #       puts value
   #     end #=> does nothing
   #
@@ -80,8 +79,19 @@ module Fear
   #   @yieldparam [any] value
   #   @yieldreturn [any]
   #   @example
-  #     Some(42).map { |v| v/2 } #=> Some(21)
-  #     None().map { |v| v/2 }   #=> None()
+  #     Fear.some(42).map { |v| v/2 } #=> Fear.some(21)
+  #     Fear.none.map { |v| v/2 }   #=> None
+  #
+  # @!method filter_map(&block)
+  #   Returns a new +Some+ of truthy results (everything except +false+ or +nil+) of
+  #   running the block or +None+ otherwise.
+  #   @yieldparam [any] value
+  #   @yieldreturn [any]
+  #   @example
+  #     Fear.some(42).filter_map { |v| v/2 if v.even? } #=> Fear.some(21)
+  #     Fear.some(42).filter_map { |v| v/2 if v.odd? } #=> Fear.none
+  #     Fear.some(42).filter_map { |v| false } #=> Fear.none
+  #     Fear.none.filter_map { |v| v/2 }   #=> Fear.none
   #
   # @!method flat_map(&block)
   #   Returns the given block applied to the value from this +Some+
@@ -90,16 +100,8 @@ module Fear
   #   @yieldreturn [Option]
   #   @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   #=> []
+  #     Fear.some(42).flat_map { |v| Fear.some(v/2) }   #=> Fear.some(21)
+  #     Fear.none.flat_map { |v| Fear.some(v/2) }     #=> None
   #
   # @!method any?(&predicate)
   #   Returns +false+ if +None+ or returns the result of the
@@ -108,9 +110,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Boolean]
   #   @example
-  #     Some(12).any?( |v| v > 10)  #=> true
-  #     Some(7).any?( |v| v > 10)   #=> false
-  #     None().any?( |v| v > 10)    #=> false
+  #     Fear.some(12).any?( |v| v > 10)  #=> true
+  #     Fear.some(7).any?( |v| v > 10)   #=> false
+  #     Fear.none.any?( |v| v > 10)    #=> false
   #
   # @!method select(&predicate)
   #   Returns self if it is nonempty and applying the predicate to this
@@ -119,9 +121,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Option]
   #   @example
-  #     Some(42).select { |v| v > 40 } #=> Success(21)
-  #     Some(42).select { |v| v < 40 } #=> None()
-  #     None().select { |v| v < 40 }   #=> None()
+  #     Fear.some(42).select { |v| v > 40 } #=> Fear.success(21)
+  #     Fear.some(42).select { |v| v < 40 } #=> None
+  #     Fear.none.select { |v| v < 40 }   #=> None
   #
   # @!method reject(&predicate)
   #   Returns +Some+ if applying the predicate to this
@@ -130,9 +132,9 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Option]
   #   @example
-  #     Some(42).reject { |v| v > 40 } #=> None
-  #     Some(42).reject { |v| v < 40 } #=> Some(42)
-  #     None().reject { |v| v < 40 }   #=> None
+  #     Fear.some(42).reject { |v| v > 40 } #=> None
+  #     Fear.some(42).reject { |v| v < 40 } #=> Fear.some(42)
+  #     Fear.none.reject { |v| v < 40 }   #=> None
   #
   # @!method get
   #   @return [any] the +Option+'s value.
@@ -142,15 +144,43 @@ module Fear
   #   Returns +true+ if the +Option+ is +None+, +false+ otherwise.
   #   @return [Boolean]
   #   @example
-  #     Some(42).empty? #=> false
-  #     None().empty?   #=> true
+  #     Fear.some(42).empty? #=> false
+  #     Fear.none.empty?   #=> true
+  #
+  # @!method match(&matcher)
+  #   Pattern match against this +Option+
+  #   @yield matcher [Fear::OptionPatternMatch]
+  #   @example
+  #     Fear.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
+  #
+  # @!method zip(other)
+  #   @param other [Fear::Option]
+  #   @return [Fear::Option] a +Fear::Some+ formed from this option and another option by
+  #     combining the corresponding elements in an array.
+  #
+  #   @example
+  #     Fear.some("foo").zip(Fear.some("bar")) #=> Fear.some(["foo", "bar"])
+  #     Fear.some("foo").zip(Fear.some("bar")) { |x, y| x + y } #=> Fear.some("foobar")
+  #     Fear.some("foo").zip(Fear.none) #=> Fear.none
+  #     Fear.none.zip(Fear.some("bar")) #=> Fear.none
   #
   # @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,38 +188,72 @@ module Fear
       Some
     end
 
+    class << self
+      # Build pattern matcher to be used later, despite off
+      # +Option#match+ method, it doesn't apply matcher immanently,
+      # but build it instead. Usually 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(Fear.some(42))
+      #
+      # @yieldparam [OptionPatternMatch]
+      # @return [Fear::PartialFunction]
+      def matcher(&matcher)
+        OptionPatternMatch.new(&matcher)
+      end
+
+      def match(value, &block)
+        matcher(&block).(value)
+      end
+    end
+
     # Include this mixin to access convenient factory methods.
     # @example
     #   include Fear::Option::Mixin
     #
-    #   Option(17)  #=> #<Fear::Some value=17>
+    #   Option(17) #=> #<Fear::Some get=17>
     #   Option(nil) #=> #<Fear::None>
-    #   Some(17)    #=> #<Fear::Some value=17>
-    #   None()      #=> #<Fear::None>
+    #   Some(17) #=> #<Fear::Some get=17>
+    #   None() #=> #<Fear::None>
     #
     module Mixin
       # An +Option+ factory which creates +Some+ if the argument is
       # not +nil+, and +None+ if it is +nil+.
       # @param value [any]
-      # @return [Some, None]
+      # @return [Fear::Some, Fear::None]
+      #
+      # @example
+      #   Option(17) #=> #<Fear::Some get=17>
+      #   Option(nil) #=> #<Fear::None>
       #
       def Option(value)
-        if value.nil?
-          None()
-        else
-          Some(value)
-        end
+        Fear.option(value)
       end
 
       # @return [None]
+      # @example
+      #   None() #=> #<Fear::None>
+      #
       def None
-        None.new
+        Fear.none
       end
 
       # @param value [any] except nil
-      # @return [None]
+      # @return [Fear::Some]
+      # @example
+      #   Some(17) #=> #<Fear::Some get=17>
+      #   Some(nil) #=> #<Fear::Some get=nil>
+      #
       def Some(value)
-        Some.new(value)
+        Fear.some(value)
       end
     end
   end