fear 1.0.0 → 1.1.0

data/lib/fear/extractor/anonymous_array_splat_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match against array splat, E.g. `[1, 2, *]` or `[1, 2, *_]`

data/lib/fear/extractor/any_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Always match, E.g. `_ : Integer` without capturing variable

data/lib/fear/extractor/array_head_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Part of recursive array matcher. Match against its head.

data/lib/fear/extractor/array_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Recursive array matcher. Match against its head and tail

data/lib/fear/extractor/array_splat_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # @abstract

data/lib/fear/extractor/empty_list_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match only if array is empty

data/lib/fear/extractor/extractor_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match and extract pattern using registered extractor objects
@@ -19,19 +21,19 @@ module Fear
 
       def defined_at?(other)
         extractor
-          .call(other)
+          .(other)
           .map { |v| arguments_matcher.defined_at?(v) }
           .get_or_else(false)
       end
 
       def call_or_else(arg)
-        extractor.call(arg)
+        extractor.(arg)
           .map { |v| arguments_matcher.call_or_else(v) { yield arg } }
           .get_or_else { yield arg }
       end
 
       def failure_reason(other)
-        extractor.call(other).match do |m|
+        extractor.(other).match do |m|
           m.some(->(v) { arguments_matcher.defined_at?(v) }) { Fear.none }
           m.some { |v| arguments_matcher.failure_reason(v) }
           m.none { super }

data/lib/fear/extractor/grammar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # This module contains AST nodes for GrammarParser
@@ -56,7 +58,7 @@ module Fear
         end
 
         def value
-          text_value.to_f
+          Float(text_value)
         end
       end
 
@@ -66,7 +68,7 @@ module Fear
         end
 
         def value
-          text_value.to_i
+          Integer(text_value, 10)
         end
       end
 
@@ -80,7 +82,7 @@ module Fear
         end
       end
 
-      require 'yaml'
+      require "yaml"
 
       class DoubleQuotedStringLiteral < StringLiteral
         def to_matcher

data/lib/fear/extractor/identifier_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     class IdentifierMatcher < Matcher

data/lib/fear/extractor/matcher.rb

@@ -1,10 +1,12 @@
-require 'ostruct'
+# frozen_string_literal: true
+
+require "ostruct"
 
 module Fear
   module Extractor
     # @abstract abstract matcher to inherit from.
     class Matcher < OpenStruct
-      autoload :And, 'fear/extractor/matcher/and'
+      autoload :And, "fear/extractor/matcher/and"
 
       EMPTY_HASH = {}.freeze
       EMPTY_ARRAY = [].freeze
@@ -46,7 +48,7 @@ module Fear
         if defined_at?(other)
           Fear.none
         else
-          Fear.some("Expected `#{other.inspect}` to match:\n#{input}\n#{'~' * input_position}^")
+          Fear.some("Expected `#{other.inspect}` to match:\n#{input}\n#{"~" * input_position}^")
         end
       end
     end

data/lib/fear/extractor/matcher/and.rb

@@ -1,4 +1,6 @@
-require 'ostruct'
+# frozen_string_literal: true
+
+require "ostruct"
 
 module Fear
   module Extractor

data/lib/fear/extractor/named_array_splat_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match against array splat, and capture rest of an array

data/lib/fear/extractor/pattern.rb

@@ -1,11 +1,13 @@
-require 'lru_redux'
+# frozen_string_literal: true
+
+require "lru_redux"
 
 module Fear
   module Extractor
     # Parse pattern. Used within +Fear[]+
     class Pattern
       DEFAULT_PATTERN_CACHE_SIZE = 10_000
-      @pattern_cache = LruRedux::Cache.new(ENV.fetch('FEAR_PATTERNS_CACHE_SIZE', DEFAULT_PATTERN_CACHE_SIZE))
+      @pattern_cache = LruRedux::Cache.new(ENV.fetch("FEAR_PATTERNS_CACHE_SIZE", DEFAULT_PATTERN_CACHE_SIZE))
 
       class << self
         attr_reader :pattern_cache
@@ -41,14 +43,14 @@ module Fear
       end
 
       def failure_reason(other)
-        matcher.failure_reason(other).get_or_else { 'It matches' }
+        matcher.failure_reason(other).get_or_else { "It matches" }
       end
 
       private def syntax_error_message(parser, pattern)
         parser.failure_reason =~ /^(Expected .+) after/m
-        "#{Regexp.last_match(1).gsub("\n", '$NEWLINE')}:\n" +
+        "#{Regexp.last_match(1).gsub("\n", "$NEWLINE")}:\n" +
         pattern.split("\n")[parser.failure_line - 1] + "\n" \
-        "#{'~' * (parser.failure_column - 1)}^\n"
+        "#{"~" * (parser.failure_column - 1)}^\n"
       end
     end
   end

data/lib/fear/extractor/typed_identifier_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match and capture identifier with specific type. E.g. +foo : Integer+

data/lib/fear/extractor/value_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module Extractor
     # Match against values -- true, false, 1, "foo" etc.

data/lib/fear/extractor_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module ExtractorApi
     # Allows to pattern match and extract matcher variables

data/lib/fear/failure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   class Failure
     include Try

data/lib/fear/failure_pattern_match.rb

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

data/lib/fear/for.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   # @see Fear.for
   module For
-    module_function # rubocop: disable Style/AccessModifierDeclarations
+    module_function
 
     # @param monads [<Fear::Option, Fear::Either, Fear::Try, Proc>]
     #
@@ -30,7 +32,7 @@ module Fear
 
     private def resolve(monad_or_proc, inner_values)
       if monad_or_proc.respond_to?(:call)
-        monad_or_proc.call(*inner_values)
+        monad_or_proc.(*inner_values)
       else
         monad_or_proc
       end

data/lib/fear/for_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module ForApi
     # Syntactic sugar for composition of  multiple monadic operations. It supports two such
@@ -60,7 +62,7 @@ module Fear
     # @return [{#map, #flat_map}]
     #
     def for(*monads, &block)
-      Fear::For.call(monads, &block)
+      Fear::For.(monads, &block)
     end
   end
 end

data/lib/fear/future.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 begin
-  require 'concurrent'
+  require "concurrent"
 rescue LoadError
   puts "You must add 'concurrent-ruby' to your Gemfile in order to use Fear::Future"
 end
-require_relative 'promise'
 
 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 +23,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 future"
       end
 
       @options = options
@@ -57,11 +72,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 +91,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 +133,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 +172,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.
     #
@@ -177,11 +250,9 @@ 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
+      on_complete_match do |m|
+        m.success { |value| promise.success(success.(value)) }
+        m.failure { |error| promise.failure(failure.(error)) }
       end
       promise.to_future
     end
@@ -222,17 +293,15 @@ module Fear
     #     end
     #   end
     #
-    def flat_map # rubocop: disable Metrics/MethodLength
+    def flat_map
       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
+      on_complete_match do |m|
+        m.case(Fear::Failure) { |failure| promise.complete!(failure) }
+        m.success do |value|
+          begin
+            yield(value).on_complete { |callback_result| promise.complete!(callback_result) }
+          rescue StandardError => error
+            promise.failure!(error)
           end
         end
       end
@@ -261,7 +330,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
@@ -306,19 +375,17 @@ 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
+    def zip(other)
       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)
+      on_complete_match do |m|
+        m.success do |value|
+          other.on_complete do |other_try|
+            promise.complete!(other_try.map { |other_value| [value, other_value] })
           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
+      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,22 +434,38 @@ 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)
+    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]