fear 1.0.0 → 2.0.0

data/lib/fear/future.rb

@@ -1,20 +1,14 @@
-begin
-  require 'concurrent'
-rescue LoadError
-  puts "You must add 'concurrent-ruby' to your Gemfile in order to use Fear::Future"
-end
-require_relative 'promise'
+# frozen_string_literal: true
 
 module Fear
   # Asynchronous computations that yield futures are created
   # with the +Fear.future+ call:
   #
-  # @example
-  #   success = "Hello"
-  #   f = Fear.future { success + ' future!' }
-  #   f.on_success do |result|
-  #     puts result
-  #   end
+  #    success = "Hello"
+  #    f = Fear.future { success + ' future!' }
+  #    f.on_success do |result|
+  #      puts result
+  #    end
   #
   # Multiple callbacks may be registered; there is no guarantee
   # that they will be executed in a particular order.
@@ -23,30 +17,45 @@ module Fear
   # that the future failed. Futures obtained through combinators
   # have the same error as the future they were obtained from.
   #
-  # @example
-  #   f = Fear.future { 5 }
-  #   g = Fear.future { 3 }
-  #   f.flat_map do |x|
-  #     g.map { |y| x + y }
-  #   end
+  #    f = Fear.future { 5 }
+  #    g = Fear.future { 3 }
+  #    f.flat_map do |x|
+  #      g.map { |y| x + y }
+  #    end
+  #
+  # The same program may be written using +Fear.for+
+  #
+  #    Fear.for(Fear.future { 5 }, Fear.future { 3 }) do |x, y|
+  #      x + y
+  #    end
+  #
+  # Futures use +Concurrent::Promise+ under the hood. +Fear.future+ accepts optional configuration Hash passed
+  # directly to underlying promise. For example, run it on custom thread pool.
   #
-  # @example the same program may be written using +Fear.for+
-  #   Fear.for(Fear.future { 5 }, Fear.future { 3 }) do |x, y|
-  #     x + y
-  #   end
+  #     require 'open-uri'
+  #
+  #     future = Fear.future(executor: :io) { open('https://example.com/') }
+  #
+  #     future.map(executor: :fast, &:read).each do |body|
+  #       puts "#{body}"
+  #     end
   #
   # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/concurrent/Future.scala
   #
   class Future
+    include Awaitable
+
     # @param promise [nil, Concurrent::Future] converts
-    #  +Concurrent::Future+ into +Fear::Future+.
+    #  +Concurrent::Promise+ into +Fear::Future+.
     # @param options [see Concurrent::Future] options will be passed
-    #   directly to +Concurrent::Future+
+    #   directly to +Concurrent::Promise+
     # @yield given block and evaluate it in the future.
     # @api private
+    # @see Fear.future
+    #
     def initialize(promise = nil, **options, &block)
       if block_given? && promise
-        raise ArgumentError, 'pass block or future'
+        raise ArgumentError, "pass block or promise"
       end
 
       @options = options
@@ -57,11 +66,11 @@ module Fear
     attr_reader :promise
     private :promise
 
-    # Calls the provided callback When this future is completed successfully.
+    # Calls the provided callback when this future is completed successfully.
     #
     # If the future has already been completed with a value,
     # this will either be applied immediately or be scheduled asynchronously.
-    # @yieldparam [value]
+    # @yieldparam [any] value
     # @return [self]
     # @see #transform
     #
@@ -76,6 +85,24 @@ module Fear
       end
     end
 
+    # When this future is completed successfully match against its result
+    #
+    # If the future has already been completed with a value,
+    # this will either be applied immediately or be scheduled asynchronously.
+    # @yieldparam [Fear::PatternMatch] m
+    # @return [self]
+    #
+    # @example
+    #   Fear.future { }.on_success_match do |m|
+    #     m.case(42) { ... }
+    #   end
+    #
+    def on_success_match
+      on_success do |value|
+        Fear.matcher { |m| yield(m) }.call_or_else(value, &:itself)
+      end
+    end
+
     # When this future is completed with a failure apply the provided callback to the error.
     #
     # If the future has already been completed with a failure,
@@ -100,6 +127,26 @@ module Fear
       end
     end
 
+    # When this future is completed with a failure match against the error.
+    #
+    # If the future has already been completed with a failure,
+    # this will either be applied immediately or be scheduled asynchronously.
+    #
+    # Will not be called in case that the future is completed with a value.
+    # @yieldparam [Fear::PatternMatch] m
+    # @return [self]
+    #
+    # @example
+    #   Fear.future { }.on_failure_match do |m|
+    #     m.case(HTTPError) { |error| ... }
+    #   end
+    #
+    def on_failure_match
+      on_failure do |error|
+        Fear.matcher { |m| yield(m) }.call_or_else(error, &:itself)
+      end
+    end
+
     # When this future is completed call the provided block.
     #
     # If the future has already been completed,
@@ -119,6 +166,26 @@ module Fear
       self
     end
 
+    # When this future is completed match against result.
+    #
+    # If the future has already been completed,
+    # this will either be applied immediately or be scheduled asynchronously.
+    # @yieldparam [Fear::TryPatternMatch]
+    # @return [self]
+    #
+    # @example
+    #   Fear.future { }.on_complete_match do |m|
+    #     m.success { |result| }
+    #     m.failure { |error| }
+    #   end
+    #
+    def on_complete_match
+      promise.add_observer do |_time, try, _error|
+        Fear::Try.matcher { |m| yield(m) }.call_or_else(try, &:itself)
+      end
+      self
+    end
+
     # Returns whether the future has already been completed with
     # a value or an error.
     #
@@ -176,12 +243,10 @@ module Fear
     #     )
     #
     def transform(success, failure)
-      promise = Promise.new(@options)
-      on_complete do |try|
-        try.match do |m|
-          m.success { |value| promise.success(success.call(value)) }
-          m.failure { |error| promise.failure(failure.call(error)) }
-        end
+      promise = Promise.new(**@options)
+      on_complete_match do |m|
+        m.success { |value| promise.success(success.(value)) }
+        m.failure { |error| promise.failure(failure.(error)) }
       end
       promise.to_future
     end
@@ -197,7 +262,7 @@ module Fear
     #   future.map { |v| v * 2 } #=> the same as Fear.future { 2 * 2 }
     #
     def map(&block)
-      promise = Promise.new(@options)
+      promise = Promise.new(**@options)
       on_complete do |try|
         promise.complete!(try.map(&block))
       end
@@ -222,18 +287,14 @@ module Fear
     #     end
     #   end
     #
-    def flat_map # rubocop: disable Metrics/MethodLength
-      promise = Promise.new(@options)
-      on_complete do |result|
-        result.match do |m|
-          m.failure { promise.complete!(result) }
-          m.success do |value|
-            begin
-              yield(value).on_complete { |callback_result| promise.complete!(callback_result) }
-            rescue StandardError => error
-              promise.failure!(error)
-            end
-          end
+    def flat_map
+      promise = Promise.new(**@options)
+      on_complete_match do |m|
+        m.case(Fear::Failure) { |failure| promise.complete!(failure) }
+        m.success do |value|
+          yield(value).on_complete { |callback_result| promise.complete!(callback_result) }
+        rescue StandardError => error
+          promise.failure!(error)
         end
       end
       promise.to_future
@@ -261,7 +322,7 @@ module Fear
         if yield(result)
           result
         else
-          raise NoSuchElementError, '#select predicate is not satisfied'
+          raise NoSuchElementError, "#select predicate is not satisfied"
         end
       end
     end
@@ -281,7 +342,7 @@ module Fear
     #
     #
     def recover(&block)
-      promise = Promise.new(@options)
+      promise = Promise.new(**@options)
       on_complete do |try|
         promise.complete!(try.recover(&block))
       end
@@ -306,19 +367,25 @@ module Fear
     #   future1.zip(future2) #=> returns the same result as Fear.future { [call_service1, call_service2] },
     #     # but it performs two calls asynchronously
     #
-    def zip(other) # rubocop: disable Metrics/MethodLength
-      promise = Promise.new(@options)
-      on_complete do |try_of_self|
-        try_of_self.match do |m|
-          m.success do |value|
-            other.on_complete do |try_of_other|
-              promise.complete!(try_of_other.map { |other_value| [value, other_value] })
-            end
-          end
-          m.failure do |error|
-            promise.failure!(error)
+    def zip(other)
+      promise = Promise.new(**@options)
+      on_complete_match do |m|
+        m.success do |value|
+          other.on_complete do |other_try|
+            promise.complete!(
+              other_try.map do |other_value|
+                if block_given?
+                  yield(value, other_value)
+                else
+                  [value, other_value]
+                end
+              end,
+            )
           end
         end
+        m.failure do |error|
+          promise.failure!(error)
+        end
       end
 
       promise.to_future
@@ -338,26 +405,20 @@ module Fear
     #   g = Fear.future { 5 }
     #   f.fallback_to(g) # evaluates to 5
     #
-    # rubocop: disable Metrics/MethodLength
     def fallback_to(fallback)
-      promise = Promise.new(@options)
-      on_complete do |try|
-        try.match do |m|
-          m.success { |value| promise.complete!(value) }
-          m.failure do |error|
-            fallback.on_complete do |fallback_try|
-              fallback_try.match do |m2|
-                m2.success { |value| promise.complete!(value) }
-                m2.failure { promise.failure!(error) }
-              end
-            end
+      promise = Promise.new(**@options)
+      on_complete_match do |m|
+        m.success { |value| promise.complete!(value) }
+        m.failure do |error|
+          fallback.on_complete_match do |m2|
+            m2.success { |value| promise.complete!(value) }
+            m2.failure { promise.failure!(error) }
           end
         end
       end
 
       promise.to_future
     end
-    # rubocop: enable Metrics/MethodLength
 
     # Applies the side-effecting block to the result of +self+ future,
     # and returns a new future with the result of this future.
@@ -373,31 +434,46 @@ module Fear
     # @example The following example prints out +5+:
     #   f = Fear.future { 5 }
     #   f.and_then do
-    #     fail 'runtime error'
+    #     m.success { }fail| 'runtime error' }
     #   end.and_then do |m|
     #     m.success { |value| puts value } # it evaluates this branch
     #     m.failure { |error| puts error.massage }
     #   end
     #
-    def and_then(&block)
-      promise = Promise.new(@options)
+    def and_then
+      promise = Promise.new(**@options)
       on_complete do |try|
-        Fear.try { try.match(&block) }
+        Fear.try do
+          Fear::Try.matcher { |m| yield(m) }.call_or_else(try, &:itself)
+        end
         promise.complete!(try)
       end
 
       promise.to_future
     end
 
+    # @api private
+    def __result__(at_most)
+      __ready__(at_most).value.get_or_else { raise "promise not completed" }
+    end
+
+    # @api private
+    def __ready__(at_most)
+      if promise.wait(at_most).complete?
+        self
+      else
+        raise Timeout::Error
+      end
+    end
+
     class << self
       # Creates an already completed +Future+ with the specified error.
       # @param exception [StandardError]
       # @return [Fear::Future]
       #
       def failed(exception)
-        new(executor: Concurrent::ImmediateExecutor.new) do
-          raise exception
-        end
+        new { raise exception }
+          .yield_self { |future| Fear::Await.ready(future, 10) }
       end
 
       # Creates an already completed +Future+ with the specified result.
@@ -405,9 +481,8 @@ module Fear
       # @return [Fear::Future]
       #
       def successful(result)
-        new(executor: Concurrent::ImmediateExecutor.new) do
-          result
-        end
+        new { result }
+          .yield_self { |future| Fear::Await.ready(future, 10) }
       end
     end
   end

data/lib/fear/future_api.rb

@@ -1,5 +1,18 @@
+# frozen_string_literal: true
+
+begin
+  require "concurrent"
+rescue LoadError
+  puts "You must add 'concurrent-ruby' to your Gemfile in order to use Fear::Future"
+end
+
+require "fear/awaitable"
+require "fear/await"
+require "fear/future"
+require "fear/promise"
+
 module Fear
-  # rubocop: disable Metrics/LineLength
+  # rubocop: disable Layout/LineLength
   module FutureApi
     # Asynchronously evaluates the block
     # @param options [Hash] options will be passed directly to underlying +Concurrent::Promise+
@@ -11,9 +24,9 @@ module Fear
     #   f = Fear.future(executor: :io) { open('http://example.com') }
     #   f.map(&:read).each { |body| puts body }
     #
-    def future(options = {}, &block)
-      Future.new(options, &block)
+    def future(**options, &block)
+      Future.new(nil, **options, &block)
     end
   end
-  # rubocop: enable Metrics/LineLength
+  # rubocop: enable Layout/LineLength
 end

data/lib/fear/left.rb

@@ -1,17 +1,11 @@
+# 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
-
     # @api private
     def left_value
       value
@@ -52,7 +46,7 @@ module Fear
     # @param reduce_left [Proc]
     # @return [any]
     def reduce(reduce_left, _reduce_right)
-      reduce_left.call(value)
+      reduce_left.(value)
     end
 
     # @return [self]

data/lib/fear/left_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class LeftPatternMatch < Fear::EitherPatternMatch

data/lib/fear/none.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class NoneClass
@@ -5,14 +7,6 @@ module Fear
     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
@@ -28,6 +22,13 @@ module Fear
       true
     end
 
+    alias :blank? :empty?
+
+    # @return [false]
+    def present?
+      false
+    end
+
     # @return [None]
     def select(*)
       self
@@ -40,7 +41,7 @@ module Fear
 
     # @return [String]
     def inspect
-      '#<Fear::NoneClass>'
+      "#<Fear::NoneClass>"
     end
 
     # @return [String]
@@ -57,12 +58,29 @@ module Fear
     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
@@ -70,7 +88,7 @@ module Fear
     end
 
     def inherited(*)
-      raise 'you are not allowed to inherit from NoneClass, use Fear::None instead'
+      raise "you are not allowed to inherit from NoneClass, use Fear::None instead"
     end
   end
 end

data/lib/fear/none_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class NonePatternMatch < OptionPatternMatch

data/lib/fear/option.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Represents optional values. Instances of +Option+
   # are either an instance of +Some+ or the object +None+.
@@ -80,6 +82,17 @@ module Fear
   #     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+
   #   or returns this if this is a +None+
@@ -108,7 +121,7 @@ module Fear
   #   @yieldreturn [Boolean]
   #   @return [Option]
   #   @example
-  #     Fear.some(42).select { |v| v > 40 } #=> Fear.success(21)
+  #     Fear.some(42).select { |v| v > 40 } #=> Fear.success(42)
   #     Fear.some(42).select { |v| v < 40 } #=> None
   #     Fear.none.select { |v| v < 40 }   #=> None
   #
@@ -151,6 +164,17 @@ module Fear
   #       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
@@ -187,7 +211,7 @@ module Fear
       end
 
       def match(value, &block)
-        matcher(&block).call(value)
+        matcher(&block).(value)
       end
     end
 
@@ -234,3 +258,7 @@ module Fear
     end
   end
 end
+
+require "fear/option_pattern_match"
+require "fear/some"
+require "fear/none"

data/lib/fear/option_api.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/option"
+
 module Fear
   module OptionApi
     # An +Option+ factory which creates +Some+ if the argument is

data/lib/fear/option_pattern_match.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
 module Fear
   # Option pattern matcher
   #
@@ -22,14 +26,12 @@ module Fear
   # @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))
+      branch = Fear.case(Fear::Some, &:get).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
 
@@ -43,3 +45,6 @@ module Fear
     end
   end
 end
+
+require "fear/some_pattern_match"
+require "fear/none_pattern_match"

data/lib/fear/partial_function/and_then.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     # Composite function produced by +PartialFunction#and_then+ method
@@ -23,7 +25,7 @@ module Fear
       # @param arg [any]
       # @return [any ]
       def call(arg)
-        function.call(partial_function.call(arg))
+        function.(partial_function.(arg))
       end
 
       # @param arg [any]
@@ -39,7 +41,7 @@ module Fear
         result = partial_function.call_or_else(arg) do
           return yield(arg)
         end
-        function.call(result)
+        function.(result)
       end
     end
 

data/lib/fear/partial_function/any.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     # Any is an object which is always truthy

data/lib/fear/partial_function/combined.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module PartialFunction
     # Composite function produced by +PartialFunction#and_then+ method
@@ -22,7 +24,7 @@ module Fear
       # @param arg [any]
       # @return [any ]
       def call(arg)
-        f2.call(f1.call(arg))
+        f2.(f1.(arg))
       end
 
       alias === call