fear 0.11.0 → 1.0.0

data/lib/fear/future_api.rb

@@ -0,0 +1,19 @@
+module Fear
+  # rubocop: disable Metrics/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 Metrics/LineLength
+end

data/lib/fear/left.rb

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

data/lib/fear/none.rb

@@ -2,10 +2,17 @@ module Fear
   # @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
+
     # @raise [NoSuchElementError]
     def get
       raise NoSuchElementError
@@ -31,16 +38,18 @@ module Fear
       self
     end
 
-    AS_STRING = 'Fear::None'.freeze
-
     # @return [String]
-    def to_s
-      AS_STRING
+    def inspect
+      '#<Fear::NoneClass>'
     end
 
     # @return [String]
-    def inspect
-      AS_STRING
+    alias to_s inspect
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(NoneClass)
     end
 
     # @param other
@@ -60,7 +69,7 @@ module Fear
       None
     end
 
-    def inherited
+    def inherited(*)
       raise 'you are not allowed to inherit from NoneClass, use Fear::None instead'
     end
   end

data/lib/fear/option.rb

@@ -3,7 +3,7 @@ module Fear
   # 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,13 +11,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
-  #   Option(params[:name]).match do |m|
+  #   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
@@ -31,21 +31,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
@@ -53,9 +53,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+.
@@ -63,11 +63,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
   #
@@ -77,8 +77,8 @@ 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 flat_map(&block)
   #   Returns the given block applied to the value from this +Some+
@@ -87,8 +87,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
+  #     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
@@ -97,9 +97,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
@@ -108,9 +108,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
@@ -119,9 +119,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.
@@ -131,14 +131,14 @@ 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
-  #     Option(val).match do |m|
+  #     Fear.option(val).match do |m|
   #       m.some(Integer) do |x|
   #        x * 2
   #       end
@@ -166,8 +166,8 @@ module Fear
 
     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
+      # +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
@@ -178,52 +178,58 @@ module Fear
       #       m.none { 'NaN' }
       #       m.else { 'error '}
       #     end
-      #   matcher.call(Some(42))
+      #   matcher.call(Fear.some(42))
       #
       # @yieldparam [OptionPatternMatch]
       # @return [Fear::PartialFunction]
       def matcher(&matcher)
         OptionPatternMatch.new(&matcher)
       end
+
+      def match(value, &block)
+        matcher(&block).call(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
-      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]
+      # @return [Fear::Some, Fear::None]
       #
       # @example
-      #   Option(v)
+      #   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
-        Fear::None
+        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

data/lib/fear/option_api.rb

@@ -0,0 +1,38 @@
+module Fear
+  module OptionApi
+    # An +Option+ factory which creates +Some+ if the argument is
+    # not +nil+, and +None+ if it is +nil+.
+    # @param value [any]
+    # @return [Fear::Some, Fear::None]
+    #
+    # @example
+    #   Fear.option(nil) #=> #<Fear::None>
+    #   Fear.option(17) #=> #<Fear::Some get=17>
+    #
+    def option(value)
+      if value.nil?
+        none
+      else
+        some(value)
+      end
+    end
+
+    # @return [Fear::None]
+    # @example
+    #   Fear.none #=> #<Fear::None>
+    #
+    def none
+      Fear::None
+    end
+
+    # @param value [any]
+    # @return [Fear::Some]
+    # @example
+    #   Fear.some(17) #=> #<Fear::Some get=17>
+    #   Fear.some(nil) #=> #<Fear::Some get=nil>
+    #
+    def some(value)
+      Fear::Some.new(value)
+    end
+  end
+end

data/lib/fear/partial_function.rb

@@ -35,6 +35,13 @@ module Fear
   #    numbers = sample.map(is_even.or_else(is_odd).to_proc)
   #
   # @see https://github.com/scala/scala/commit/5050915eb620af3aa43d6ddaae6bbb83ad74900d
+  # @!method condition
+  #   describes the domain of partial function
+  #   @return [#===]
+  #   @abstract
+  # @!method function
+  #   @return [#call]
+  #   @abstract
   module PartialFunction
     autoload :AndThen, 'fear/partial_function/and_then'
     autoload :Any, 'fear/partial_function/any'
@@ -44,16 +51,6 @@ module Fear
     autoload :Lifted, 'fear/partial_function/lifted'
     autoload :OrElse, 'fear/partial_function/or_else'
 
-    # @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
-
     # Checks if a value is contained in the function's domain.
     #
     # @param arg [any]
@@ -151,7 +148,7 @@ module Fear
     class << self
       # Creates partial function guarded by several condition.
       # All guards should match.
-      # @param guards [<#===, symbol>]
+      # @param guards [<#===>]
       # @param function [Proc]
       # @return [Fear::PartialFunction]
       def and(*guards, &function)
@@ -160,7 +157,7 @@ module Fear
 
       # Creates partial function guarded by several condition.
       # Any condition should match.
-      # @param guards [<#===, symbol>]
+      # @param guards [<#===>]
       # @param function [Proc]
       # @return [Fear::PartialFunction]
       def or(*guards, &function)

data/lib/fear/partial_function/empty.rb

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

data/lib/fear/partial_function/guard.rb

@@ -11,28 +11,21 @@ module Fear
       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.
+        # a value withing container.
         #
         def and2(c1, c2)
-          Guard::And.new(
-            (c1.is_a?(Symbol) ? c1.to_proc : c1),
-            (c2.is_a?(Symbol) ? c2.to_proc : c2),
-          )
+          Guard::And.new(c1, 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),
-          )
+          Guard::And3.new(c1, c2, c3)
         end
 
         def and1(c)
-          c.is_a?(Symbol) ? c.to_proc : c
+          c
         end
 
-        # @param conditions [<#===, Symbol>]
+        # @param conditions [<#===>]
         # @return [Fear::PartialFunction::Guard]
         def and(conditions)
           case conditions.size
@@ -46,7 +39,7 @@ module Fear
           end
         end
 
-        # @param conditions [<#===, Symbol>]
+        # @param conditions [<#===>]
         # @return [Fear::PartialFunction::Guard]
         def or(conditions)
           return Any if conditions.empty?
@@ -56,14 +49,9 @@ module Fear
         end
       end
 
-      # @param condition [<#===, Symbol>]
+      # @param condition [#===]
       def initialize(condition)
-        @condition =
-          if condition.is_a?(Symbol)
-            condition.to_proc
-          else
-            condition
-          end
+        @condition = condition
       end
       attr_reader :condition
       private :condition