honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/promises.rb

@@ -1,2168 +0,0 @@
-require 'concurrent/synchronization/object'
-require 'concurrent/atomic/atomic_boolean'
-require 'concurrent/atomic/atomic_fixnum'
-require 'concurrent/collection/lock_free_stack'
-require 'concurrent/configuration'
-require 'concurrent/errors'
-require 'concurrent/re_include'
-
-module Concurrent
-
-  # {include:file:docs-source/promises-main.md}
-  module Promises
-
-    # @!macro promises.param.default_executor
-    #   @param [Executor, :io, :fast] default_executor Instance of an executor or a name of the
-    #     global executor. Default executor propagates to chained futures unless overridden with
-    #     executor parameter or changed with {AbstractEventFuture#with_default_executor}.
-    #
-    # @!macro promises.param.executor
-    #   @param [Executor, :io, :fast] executor Instance of an executor or a name of the
-    #     global executor. The task is executed on it, default executor remains unchanged.
-    #
-    # @!macro promises.param.args
-    #   @param [Object] args arguments which are passed to the task when it's executed.
-    #     (It might be prepended with other arguments, see the @yeild section).
-    #
-    # @!macro promises.shortcut.on
-    #   Shortcut of {#$0_on} with default `:io` executor supplied.
-    #   @see #$0_on
-    #
-    # @!macro promises.shortcut.using
-    #   Shortcut of {#$0_using} with default `:io` executor supplied.
-    #   @see #$0_using
-    #
-    # @!macro promise.param.task-future
-    #  @yieldreturn will become result of the returned Future.
-    #     Its returned value becomes {Future#value} fulfilling it,
-    #     raised exception becomes {Future#reason} rejecting it.
-    #
-    # @!macro promise.param.callback
-    #  @yieldreturn is forgotten.
-
-    # Container of all {Future}, {Event} factory methods. They are never constructed directly with
-    # new.
-    module FactoryMethods
-      extend ReInclude
-      extend self
-
-      module Configuration
-        # @return [Executor, :io, :fast] the executor which is used when none is supplied
-        #   to a factory method. The method can be overridden in the receivers of
-        #   `include FactoryMethod`
-        def default_executor
-          :io
-        end
-      end
-
-      include Configuration
-
-      # @!macro promises.shortcut.on
-      # @return [ResolvableEvent]
-      def resolvable_event
-        resolvable_event_on default_executor
-      end
-
-      # Created resolvable event, user is responsible for resolving the event once by
-      # {Promises::ResolvableEvent#resolve}.
-      #
-      # @!macro promises.param.default_executor
-      # @return [ResolvableEvent]
-      def resolvable_event_on(default_executor = self.default_executor)
-        ResolvableEventPromise.new(default_executor).future
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [ResolvableFuture]
-      def resolvable_future
-        resolvable_future_on default_executor
-      end
-
-      # Creates resolvable future, user is responsible for resolving the future once by
-      # {Promises::ResolvableFuture#resolve}, {Promises::ResolvableFuture#fulfill},
-      # or {Promises::ResolvableFuture#reject}
-      #
-      # @!macro promises.param.default_executor
-      # @return [ResolvableFuture]
-      def resolvable_future_on(default_executor = self.default_executor)
-        ResolvableFuturePromise.new(default_executor).future
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def future(*args, &task)
-        future_on(default_executor, *args, &task)
-      end
-
-      # Constructs new Future which will be resolved after block is evaluated on default executor.
-      # Evaluation begins immediately.
-      #
-      # @!macro promises.param.default_executor
-      # @!macro promises.param.args
-      # @yield [*args] to the task.
-      # @!macro promise.param.task-future
-      # @return [Future]
-      def future_on(default_executor, *args, &task)
-        ImmediateEventPromise.new(default_executor).future.then(*args, &task)
-      end
-
-      # Creates resolved future with will be either fulfilled with the given value or rejection with
-      # the given reason.
-      #
-      # @param [true, false] fulfilled
-      # @param [Object] value
-      # @param [Object] reason
-      # @!macro promises.param.default_executor
-      # @return [Future]
-      def resolved_future(fulfilled, value, reason, default_executor = self.default_executor)
-        ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
-      end
-
-      # Creates resolved future with will be fulfilled with the given value.
-      #
-      # @!macro promises.param.default_executor
-      # @param [Object] value
-      # @return [Future]
-      def fulfilled_future(value, default_executor = self.default_executor)
-        resolved_future true, value, nil, default_executor
-      end
-
-      # Creates resolved future with will be rejected with the given reason.
-      #
-      # @!macro promises.param.default_executor
-      # @param [Object] reason
-      # @return [Future]
-      def rejected_future(reason, default_executor = self.default_executor)
-        resolved_future false, nil, reason, default_executor
-      end
-
-      # Creates resolved event.
-      #
-      # @!macro promises.param.default_executor
-      # @return [Event]
-      def resolved_event(default_executor = self.default_executor)
-        ImmediateEventPromise.new(default_executor).event
-      end
-
-      # General constructor. Behaves differently based on the argument's type. It's provided for convenience
-      # but it's better to be explicit.
-      #
-      # @see rejected_future, resolved_event, fulfilled_future
-      # @!macro promises.param.default_executor
-      # @return [Event, Future]
-      #
-      # @overload make_future(nil, default_executor = self.default_executor)
-      #   @param [nil] nil
-      #   @return [Event] resolved event.
-      #
-      # @overload make_future(a_future, default_executor = self.default_executor)
-      #   @param [Future] a_future
-      #   @return [Future] a future which will be resolved when a_future is.
-      #
-      # @overload make_future(an_event, default_executor = self.default_executor)
-      #   @param [Event] an_event
-      #   @return [Event] an event which will be resolved when an_event is.
-      #
-      # @overload make_future(exception, default_executor = self.default_executor)
-      #   @param [Exception] exception
-      #   @return [Future] a rejected future with the exception as its reason.
-      #
-      # @overload make_future(value, default_executor = self.default_executor)
-      #   @param [Object] value when none of the above overloads fits
-      #   @return [Future] a fulfilled future with the value.
-      def make_future(argument = nil, default_executor = self.default_executor)
-        case argument
-        when AbstractEventFuture
-          # returning wrapper would change nothing
-          argument
-        when Exception
-          rejected_future argument, default_executor
-        when nil
-          resolved_event default_executor
-        else
-          fulfilled_future argument, default_executor
-        end
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future, Event]
-      def delay(*args, &task)
-        delay_on default_executor, *args, &task
-      end
-
-      # Creates new event or future which is resolved only after it is touched,
-      # see {Concurrent::AbstractEventFuture#touch}.
-      #
-      # @!macro promises.param.default_executor
-      # @overload delay_on(default_executor, *args, &task)
-      #   If task is provided it returns a {Future} representing the result of the task.
-      #   @!macro promises.param.args
-      #   @yield [*args] to the task.
-      #   @!macro promise.param.task-future
-      #   @return [Future]
-      # @overload delay_on(default_executor)
-      #   If no task is provided, it returns an {Event}
-      #   @return [Event]
-      def delay_on(default_executor, *args, &task)
-        event = DelayPromise.new(default_executor).event
-        task ? event.chain(*args, &task) : event
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future, Event]
-      def schedule(intended_time, *args, &task)
-        schedule_on default_executor, intended_time, *args, &task
-      end
-
-      # Creates new event or future which is resolved in intended_time.
-      #
-      # @!macro promises.param.default_executor
-      # @!macro promises.param.intended_time
-      #   @param [Numeric, Time] intended_time `Numeric` means to run in `intended_time` seconds.
-      #     `Time` means to run on `intended_time`.
-      # @overload schedule_on(default_executor, intended_time, *args, &task)
-      #   If task is provided it returns a {Future} representing the result of the task.
-      #   @!macro promises.param.args
-      #   @yield [*args] to the task.
-      #   @!macro promise.param.task-future
-      #   @return [Future]
-      # @overload schedule_on(default_executor, intended_time)
-      #   If no task is provided, it returns an {Event}
-      #   @return [Event]
-      def schedule_on(default_executor, intended_time, *args, &task)
-        event = ScheduledPromise.new(default_executor, intended_time).event
-        task ? event.chain(*args, &task) : event
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def zip_futures(*futures_and_or_events)
-        zip_futures_on default_executor, *futures_and_or_events
-      end
-
-      # Creates new future which is resolved after all futures_and_or_events are resolved.
-      # Its value is array of zipped future values. Its reason is array of reasons for rejection.
-      # If there is an error it rejects.
-      # @!macro promises.event-conversion
-      #   If event is supplied, which does not have value and can be only resolved, it's
-      #   represented as `:fulfilled` with value `nil`.
-      #
-      # @!macro promises.param.default_executor
-      # @param [AbstractEventFuture] futures_and_or_events
-      # @return [Future]
-      def zip_futures_on(default_executor, *futures_and_or_events)
-        ZipFuturesPromise.new_blocked_by(futures_and_or_events, default_executor).future
-      end
-
-      alias_method :zip, :zip_futures
-
-      # @!macro promises.shortcut.on
-      # @return [Event]
-      def zip_events(*futures_and_or_events)
-        zip_events_on default_executor, *futures_and_or_events
-      end
-
-      # Creates new event which is resolved after all futures_and_or_events are resolved.
-      # (Future is resolved when fulfilled or rejected.)
-      #
-      # @!macro promises.param.default_executor
-      # @param [AbstractEventFuture] futures_and_or_events
-      # @return [Event]
-      def zip_events_on(default_executor, *futures_and_or_events)
-        ZipEventsPromise.new_blocked_by(futures_and_or_events, default_executor).event
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def any_resolved_future(*futures_and_or_events)
-        any_resolved_future_on default_executor, *futures_and_or_events
-      end
-
-      alias_method :any, :any_resolved_future
-
-      # Creates new future which is resolved after first futures_and_or_events is resolved.
-      # Its result equals result of the first resolved future.
-      # @!macro promises.any-touch
-      #   If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
-      #   futures un-executed if they are not required any more.
-      # @!macro promises.event-conversion
-      #
-      # @!macro promises.param.default_executor
-      # @param [AbstractEventFuture] futures_and_or_events
-      # @return [Future]
-      def any_resolved_future_on(default_executor, *futures_and_or_events)
-        AnyResolvedFuturePromise.new_blocked_by(futures_and_or_events, default_executor).future
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def any_fulfilled_future(*futures_and_or_events)
-        any_fulfilled_future_on default_executor, *futures_and_or_events
-      end
-
-      # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
-      # Its result equals result of the first resolved future or if all futures_and_or_events reject,
-      # it has reason of the last resolved future.
-      # @!macro promises.any-touch
-      # @!macro promises.event-conversion
-      #
-      # @!macro promises.param.default_executor
-      # @param [AbstractEventFuture] futures_and_or_events
-      # @return [Future]
-      def any_fulfilled_future_on(default_executor, *futures_and_or_events)
-        AnyFulfilledFuturePromise.new_blocked_by(futures_and_or_events, default_executor).future
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Event]
-      def any_event(*futures_and_or_events)
-        any_event_on default_executor, *futures_and_or_events
-      end
-
-      # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
-      # @!macro promises.any-touch
-      #
-      # @!macro promises.param.default_executor
-      # @param [AbstractEventFuture] futures_and_or_events
-      # @return [Event]
-      def any_event_on(default_executor, *futures_and_or_events)
-        AnyResolvedEventPromise.new_blocked_by(futures_and_or_events, default_executor).event
-      end
-
-      # TODO consider adding first(count, *futures)
-      # TODO consider adding zip_by(slice, *futures) processing futures in slices
-      # TODO or rather a generic aggregator taking a function
-    end
-
-    module InternalStates
-      # @!visibility private
-      class State
-        def resolved?
-          raise NotImplementedError
-        end
-
-        def to_sym
-          raise NotImplementedError
-        end
-      end
-
-      # @!visibility private
-      class Pending < State
-        def resolved?
-          false
-        end
-
-        def to_sym
-          :pending
-        end
-      end
-
-      # @!visibility private
-      class Reserved < Pending
-      end
-
-      # @!visibility private
-      class ResolvedWithResult < State
-        def resolved?
-          true
-        end
-
-        def to_sym
-          :resolved
-        end
-
-        def result
-          [fulfilled?, value, reason]
-        end
-
-        def fulfilled?
-          raise NotImplementedError
-        end
-
-        def value
-          raise NotImplementedError
-        end
-
-        def reason
-          raise NotImplementedError
-        end
-
-        def apply
-          raise NotImplementedError
-        end
-      end
-
-      # @!visibility private
-      class Fulfilled < ResolvedWithResult
-
-        def initialize(value)
-          @Value = value
-        end
-
-        def fulfilled?
-          true
-        end
-
-        def apply(args, block)
-          block.call value, *args
-        end
-
-        def value
-          @Value
-        end
-
-        def reason
-          nil
-        end
-
-        def to_sym
-          :fulfilled
-        end
-      end
-
-      # @!visibility private
-      class FulfilledArray < Fulfilled
-        def apply(args, block)
-          block.call(*value, *args)
-        end
-      end
-
-      # @!visibility private
-      class Rejected < ResolvedWithResult
-        def initialize(reason)
-          @Reason = reason
-        end
-
-        def fulfilled?
-          false
-        end
-
-        def value
-          nil
-        end
-
-        def reason
-          @Reason
-        end
-
-        def to_sym
-          :rejected
-        end
-
-        def apply(args, block)
-          block.call reason, *args
-        end
-      end
-
-      # @!visibility private
-      class PartiallyRejected < ResolvedWithResult
-        def initialize(value, reason)
-          super()
-          @Value  = value
-          @Reason = reason
-        end
-
-        def fulfilled?
-          false
-        end
-
-        def to_sym
-          :rejected
-        end
-
-        def value
-          @Value
-        end
-
-        def reason
-          @Reason
-        end
-
-        def apply(args, block)
-          block.call(*reason, *args)
-        end
-      end
-
-      # @!visibility private
-      PENDING = Pending.new
-      # @!visibility private
-      RESERVED = Reserved.new
-      # @!visibility private
-      RESOLVED = Fulfilled.new(nil)
-
-      def RESOLVED.to_sym
-        :resolved
-      end
-    end
-
-    private_constant :InternalStates
-
-    # @!macro promises.shortcut.event-future
-    #   @see Event#$0
-    #   @see Future#$0
-
-    # @!macro promises.param.timeout
-    #   @param [Numeric] timeout the maximum time in second to wait.
-
-    # @!macro promises.warn.blocks
-    #   @note This function potentially blocks current thread until the Future is resolved.
-    #     Be careful it can deadlock. Try to chain instead.
-
-    # Common ancestor of {Event} and {Future} classes, many shared methods are defined here.
-    class AbstractEventFuture < Synchronization::Object
-      safe_initialization!
-      attr_atomic(:internal_state)
-      private :internal_state=, :swap_internal_state, :compare_and_set_internal_state, :update_internal_state
-      # @!method internal_state
-      #   @!visibility private
-
-      include InternalStates
-
-      def initialize(promise, default_executor)
-        super()
-        @Lock               = Mutex.new
-        @Condition          = ConditionVariable.new
-        @Promise            = promise
-        @DefaultExecutor    = default_executor
-        @Callbacks          = LockFreeStack.new
-        @Waiters            = AtomicFixnum.new 0
-        self.internal_state = PENDING
-      end
-
-      private :initialize
-
-      # Returns its state.
-      # @return [Symbol]
-      #
-      # @overload an_event.state
-      #   @return [:pending, :resolved]
-      # @overload a_future.state
-      #   Both :fulfilled, :rejected implies :resolved.
-      #   @return [:pending, :fulfilled, :rejected]
-      def state
-        internal_state.to_sym
-      end
-
-      # Is it in pending state?
-      # @return [Boolean]
-      def pending?
-        !internal_state.resolved?
-      end
-
-      # Is it in resolved state?
-      # @return [Boolean]
-      def resolved?
-        internal_state.resolved?
-      end
-
-      # Propagates touch. Requests all the delayed futures, which it depends on, to be
-      # executed. This method is called by any other method requiring resolved state, like {#wait}.
-      # @return [self]
-      def touch
-        @Promise.touch
-        self
-      end
-
-      # @!macro promises.touches
-      #   Calls {Concurrent::AbstractEventFuture#touch}.
-
-      # @!macro promises.method.wait
-      #   Wait (block the Thread) until receiver is {#resolved?}.
-      #   @!macro promises.touches
-      #
-      #   @!macro promises.warn.blocks
-      #   @!macro promises.param.timeout
-      #   @return [self, true, false] self implies timeout was not used, true implies timeout was used
-      #     and it was resolved, false implies it was not resolved within timeout.
-      def wait(timeout = nil)
-        result = wait_until_resolved(timeout)
-        timeout ? result : self
-      end
-
-      # Returns default executor.
-      # @return [Executor] default executor
-      # @see #with_default_executor
-      # @see FactoryMethods#future_on
-      # @see FactoryMethods#resolvable_future
-      # @see FactoryMethods#any_fulfilled_future_on
-      # @see similar
-      def default_executor
-        @DefaultExecutor
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def chain(*args, &task)
-        chain_on @DefaultExecutor, *args, &task
-      end
-
-      # Chains the task to be executed asynchronously on executor after it is resolved.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @return [Future]
-      # @!macro promise.param.task-future
-      #
-      # @overload an_event.chain_on(executor, *args, &task)
-      #   @yield [*args] to the task.
-      # @overload a_future.chain_on(executor, *args, &task)
-      #   @yield [fulfilled, value, reason, *args] to the task.
-      #   @yieldparam [true, false] fulfilled
-      #   @yieldparam [Object] value
-      #   @yieldparam [Object] reason
-      def chain_on(executor, *args, &task)
-        ChainPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
-      end
-
-      # @return [String] Short string representation.
-      def to_s
-        format '%s %s>', super[0..-2], state
-      end
-
-      alias_method :inspect, :to_s
-
-      # Resolves the resolvable when receiver is resolved.
-      #
-      # @param [Resolvable] resolvable
-      # @return [self]
-      def chain_resolvable(resolvable)
-        on_resolution! { resolvable.resolve_with internal_state }
-      end
-
-      alias_method :tangle, :chain_resolvable
-
-      # @!macro promises.shortcut.using
-      # @return [self]
-      def on_resolution(*args, &callback)
-        on_resolution_using @DefaultExecutor, *args, &callback
-      end
-
-      # Stores the callback to be executed synchronously on resolving thread after it is
-      # resolved.
-      #
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      #
-      # @overload an_event.on_resolution!(*args, &callback)
-      #   @yield [*args] to the callback.
-      # @overload a_future.on_resolution!(*args, &callback)
-      #   @yield [fulfilled, value, reason, *args] to the callback.
-      #   @yieldparam [true, false] fulfilled
-      #   @yieldparam [Object] value
-      #   @yieldparam [Object] reason
-      def on_resolution!(*args, &callback)
-        add_callback :callback_on_resolution, args, callback
-      end
-
-      # Stores the callback to be executed asynchronously on executor after it is resolved.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      #
-      # @overload an_event.on_resolution_using(executor, *args, &callback)
-      #   @yield [*args] to the callback.
-      # @overload a_future.on_resolution_using(executor, *args, &callback)
-      #   @yield [fulfilled, value, reason, *args] to the callback.
-      #   @yieldparam [true, false] fulfilled
-      #   @yieldparam [Object] value
-      #   @yieldparam [Object] reason
-      def on_resolution_using(executor, *args, &callback)
-        add_callback :async_callback_on_resolution, executor, args, callback
-      end
-
-      # @!macro promises.method.with_default_executor
-      #   Crates new object with same class with the executor set as its new default executor.
-      #   Any futures depending on it will use the new default executor.
-      # @!macro promises.shortcut.event-future
-      # @abstract
-      # @return [AbstractEventFuture]
-      def with_default_executor(executor)
-        raise NotImplementedError
-      end
-
-      # @!visibility private
-      def resolve_with(state, raise_on_reassign = true, reserved = false)
-        if compare_and_set_internal_state(reserved ? RESERVED : PENDING, state)
-          # go to synchronized block only if there were waiting threads
-          @Lock.synchronize { @Condition.broadcast } unless @Waiters.value == 0
-          call_callbacks state
-        else
-          return rejected_resolution(raise_on_reassign, state)
-        end
-        self
-      end
-
-      # For inspection.
-      # @!visibility private
-      # @return [Array<AbstractPromise>]
-      def blocks
-        @Callbacks.each_with_object([]) do |(method, args), promises|
-          promises.push(args[0]) if method == :callback_notify_blocked
-        end
-      end
-
-      # For inspection.
-      # @!visibility private
-      def callbacks
-        @Callbacks.each.to_a
-      end
-
-      # For inspection.
-      # @!visibility private
-      def promise
-        @Promise
-      end
-
-      # For inspection.
-      # @!visibility private
-      def touched?
-        promise.touched?
-      end
-
-      # For inspection.
-      # @!visibility private
-      def waiting_threads
-        @Waiters.each.to_a
-      end
-
-      # @!visibility private
-      def add_callback_notify_blocked(promise, index)
-        add_callback :callback_notify_blocked, promise, index
-      end
-
-      # @!visibility private
-      def add_callback_clear_delayed_node(node)
-        add_callback(:callback_clear_delayed_node, node)
-      end
-
-      # @!visibility private
-      def with_hidden_resolvable
-        # TODO (pitr-ch 10-Dec-2018): documentation, better name if in edge
-        self
-      end
-
-      private
-
-      def add_callback(method, *args)
-        state = internal_state
-        if state.resolved?
-          call_callback method, state, args
-        else
-          @Callbacks.push [method, args]
-          state = internal_state
-          # take back if it was resolved in the meanwhile
-          call_callbacks state if state.resolved?
-        end
-        self
-      end
-
-      def callback_clear_delayed_node(state, node)
-        node.value = nil
-      end
-
-      # @return [Boolean]
-      def wait_until_resolved(timeout)
-        return true if resolved?
-
-        touch
-
-        @Lock.synchronize do
-          @Waiters.increment
-          begin
-            unless resolved?
-              @Condition.wait @Lock, timeout
-            end
-          ensure
-            # JRuby may raise ConcurrencyError
-            @Waiters.decrement
-          end
-        end
-        resolved?
-      end
-
-      def call_callback(method, state, args)
-        self.send method, state, *args
-      end
-
-      def call_callbacks(state)
-        method, args = @Callbacks.pop
-        while method
-          call_callback method, state, args
-          method, args = @Callbacks.pop
-        end
-      end
-
-      def with_async(executor, *args, &block)
-        Concurrent.executor(executor).post(*args, &block)
-      end
-
-      def async_callback_on_resolution(state, executor, args, callback)
-        with_async(executor, state, args, callback) do |st, ar, cb|
-          callback_on_resolution st, ar, cb
-        end
-      end
-
-      def callback_notify_blocked(state, promise, index)
-        promise.on_blocker_resolution self, index
-      end
-    end
-
-    # Represents an event which will happen in future (will be resolved). The event is either
-    # pending or resolved. It should be always resolved. Use {Future} to communicate rejections and
-    # cancellation.
-    class Event < AbstractEventFuture
-
-      alias_method :then, :chain
-
-
-      # @!macro promises.method.zip
-      #   Creates a new event or a future which will be resolved when receiver and other are.
-      #   Returns an event if receiver and other are events, otherwise returns a future.
-      #   If just one of the parties is Future then the result
-      #   of the returned future is equal to the result of the supplied future. If both are futures
-      #   then the result is as described in {FactoryMethods#zip_futures_on}.
-      #
-      # @return [Future, Event]
-      def zip(other)
-        if other.is_a?(Future)
-          ZipFutureEventPromise.new_blocked_by2(other, self, @DefaultExecutor).future
-        else
-          ZipEventEventPromise.new_blocked_by2(self, other, @DefaultExecutor).event
-        end
-      end
-
-      alias_method :&, :zip
-
-      # Creates a new event which will be resolved when the first of receiver, `event_or_future`
-      # resolves.
-      #
-      # @return [Event]
-      def any(event_or_future)
-        AnyResolvedEventPromise.new_blocked_by2(self, event_or_future, @DefaultExecutor).event
-      end
-
-      alias_method :|, :any
-
-      # Creates new event dependent on receiver which will not evaluate until touched, see {#touch}.
-      # In other words, it inserts delay into the chain of Futures making rest of it lazy evaluated.
-      #
-      # @return [Event]
-      def delay
-        event = DelayPromise.new(@DefaultExecutor).event
-        ZipEventEventPromise.new_blocked_by2(self, event, @DefaultExecutor).event
-      end
-
-      # @!macro promise.method.schedule
-      #   Creates new event dependent on receiver scheduled to execute on/in intended_time.
-      #   In time is interpreted from the moment the receiver is resolved, therefore it inserts
-      #   delay into the chain.
-      #
-      #   @!macro promises.param.intended_time
-      # @return [Event]
-      def schedule(intended_time)
-        chain do
-          event = ScheduledPromise.new(@DefaultExecutor, intended_time).event
-          ZipEventEventPromise.new_blocked_by2(self, event, @DefaultExecutor).event
-        end.flat_event
-      end
-
-      # Converts event to a future. The future is fulfilled when the event is resolved, the future may never fail.
-      #
-      # @return [Future]
-      def to_future
-        future = Promises.resolvable_future
-      ensure
-        chain_resolvable(future)
-      end
-
-      # Returns self, since this is event
-      # @return [Event]
-      def to_event
-        self
-      end
-
-      # @!macro promises.method.with_default_executor
-      # @return [Event]
-      def with_default_executor(executor)
-        EventWrapperPromise.new_blocked_by1(self, executor).event
-      end
-
-      private
-
-      def rejected_resolution(raise_on_reassign, state)
-        raise Concurrent::MultipleAssignmentError.new('Event can be resolved only once') if raise_on_reassign
-        return false
-      end
-
-      def callback_on_resolution(state, args, callback)
-        callback.call(*args)
-      end
-    end
-
-    # Represents a value which will become available in future. May reject with a reason instead,
-    # e.g. when the tasks raises an exception.
-    class Future < AbstractEventFuture
-
-      # Is it in fulfilled state?
-      # @return [Boolean]
-      def fulfilled?
-        state = internal_state
-        state.resolved? && state.fulfilled?
-      end
-
-      # Is it in rejected state?
-      # @return [Boolean]
-      def rejected?
-        state = internal_state
-        state.resolved? && !state.fulfilled?
-      end
-
-      # @!macro promises.warn.nil
-      #   @note Make sure returned `nil` is not confused with timeout, no value when rejected,
-      #     no reason when fulfilled, etc.
-      #     Use more exact methods if needed, like {#wait}, {#value!}, {#result}, etc.
-
-      # @!macro promises.method.value
-      #   Return value of the future.
-      #   @!macro promises.touches
-      #
-      #   @!macro promises.warn.blocks
-      #   @!macro promises.warn.nil
-      #   @!macro promises.param.timeout
-      #   @!macro promises.param.timeout_value
-      #     @param [Object] timeout_value a value returned by the method when it times out
-      # @return [Object, nil, timeout_value] the value of the Future when fulfilled,
-      #   timeout_value on timeout,
-      #   nil on rejection.
-      def value(timeout = nil, timeout_value = nil)
-        if wait_until_resolved timeout
-          internal_state.value
-        else
-          timeout_value
-        end
-      end
-
-      # Returns reason of future's rejection.
-      # @!macro promises.touches
-      #
-      # @!macro promises.warn.blocks
-      # @!macro promises.warn.nil
-      # @!macro promises.param.timeout
-      # @!macro promises.param.timeout_value
-      # @return [Object, timeout_value] the reason, or timeout_value on timeout, or nil on fulfillment.
-      def reason(timeout = nil, timeout_value = nil)
-        if wait_until_resolved timeout
-          internal_state.reason
-        else
-          timeout_value
-        end
-      end
-
-      # Returns triplet fulfilled?, value, reason.
-      # @!macro promises.touches
-      #
-      # @!macro promises.warn.blocks
-      # @!macro promises.param.timeout
-      # @return [Array(Boolean, Object, Object), nil] triplet of fulfilled?, value, reason, or nil
-      #   on timeout.
-      def result(timeout = nil)
-        internal_state.result if wait_until_resolved timeout
-      end
-
-      # @!macro promises.method.wait
-      # @raise [Exception] {#reason} on rejection
-      def wait!(timeout = nil)
-        result = wait_until_resolved!(timeout)
-        timeout ? result : self
-      end
-
-      # @!macro promises.method.value
-      # @return [Object, nil, timeout_value] the value of the Future when fulfilled,
-      #   or nil on rejection,
-      #   or timeout_value on timeout.
-      # @raise [Exception] {#reason} on rejection
-      def value!(timeout = nil, timeout_value = nil)
-        if wait_until_resolved! timeout
-          internal_state.value
-        else
-          timeout_value
-        end
-      end
-
-      # Allows rejected Future to be risen with `raise` method.
-      # If the reason is not an exception `Runtime.new(reason)` is returned.
-      #
-      # @example
-      #   raise Promises.rejected_future(StandardError.new("boom"))
-      #   raise Promises.rejected_future("or just boom")
-      # @raise [Concurrent::Error] when raising not rejected future
-      # @return [Exception]
-      def exception(*args)
-        raise Concurrent::Error, 'it is not rejected' unless rejected?
-        raise ArgumentError unless args.size <= 1
-        reason = Array(internal_state.reason).flatten.compact
-        if reason.size > 1
-          ex = Concurrent::MultipleErrors.new reason
-          ex.set_backtrace(caller)
-          ex
-        else
-          ex = if reason[0].respond_to? :exception
-                 reason[0].exception(*args)
-               else
-                 RuntimeError.new(reason[0]).exception(*args)
-               end
-          ex.set_backtrace Array(ex.backtrace) + caller
-          ex
-        end
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def then(*args, &task)
-        then_on @DefaultExecutor, *args, &task
-      end
-
-      # Chains the task to be executed asynchronously on executor after it fulfills. Does not run
-      # the task if it rejects. It will resolve though, triggering any dependent futures.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @!macro promise.param.task-future
-      # @return [Future]
-      # @yield [value, *args] to the task.
-      def then_on(executor, *args, &task)
-        ThenPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
-      end
-
-      # @!macro promises.shortcut.on
-      # @return [Future]
-      def rescue(*args, &task)
-        rescue_on @DefaultExecutor, *args, &task
-      end
-
-      # Chains the task to be executed asynchronously on executor after it rejects. Does not run
-      # the task if it fulfills. It will resolve though, triggering any dependent futures.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @!macro promise.param.task-future
-      # @return [Future]
-      # @yield [reason, *args] to the task.
-      def rescue_on(executor, *args, &task)
-        RescuePromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
-      end
-
-      # @!macro promises.method.zip
-      # @return [Future]
-      def zip(other)
-        if other.is_a?(Future)
-          ZipFuturesPromise.new_blocked_by2(self, other, @DefaultExecutor).future
-        else
-          ZipFutureEventPromise.new_blocked_by2(self, other, @DefaultExecutor).future
-        end
-      end
-
-      alias_method :&, :zip
-
-      # Creates a new event which will be resolved when the first of receiver, `event_or_future`
-      # resolves. Returning future will have value nil if event_or_future is event and resolves
-      # first.
-      #
-      # @return [Future]
-      def any(event_or_future)
-        AnyResolvedFuturePromise.new_blocked_by2(self, event_or_future, @DefaultExecutor).future
-      end
-
-      alias_method :|, :any
-
-      # Creates new future dependent on receiver which will not evaluate until touched, see {#touch}.
-      # In other words, it inserts delay into the chain of Futures making rest of it lazy evaluated.
-      #
-      # @return [Future]
-      def delay
-        event = DelayPromise.new(@DefaultExecutor).event
-        ZipFutureEventPromise.new_blocked_by2(self, event, @DefaultExecutor).future
-      end
-
-      # @!macro promise.method.schedule
-      # @return [Future]
-      def schedule(intended_time)
-        chain do
-          event = ScheduledPromise.new(@DefaultExecutor, intended_time).event
-          ZipFutureEventPromise.new_blocked_by2(self, event, @DefaultExecutor).future
-        end.flat
-      end
-
-      # @!macro promises.method.with_default_executor
-      # @return [Future]
-      def with_default_executor(executor)
-        FutureWrapperPromise.new_blocked_by1(self, executor).future
-      end
-
-      # Creates new future which will have result of the future returned by receiver. If receiver
-      # rejects it will have its rejection.
-      #
-      # @param [Integer] level how many levels of futures should flatten
-      # @return [Future]
-      def flat_future(level = 1)
-        FlatFuturePromise.new_blocked_by1(self, level, @DefaultExecutor).future
-      end
-
-      alias_method :flat, :flat_future
-
-      # Creates new event which will be resolved when the returned event by receiver is.
-      # Be careful if the receiver rejects it will just resolve since Event does not hold reason.
-      #
-      # @return [Event]
-      def flat_event
-        FlatEventPromise.new_blocked_by1(self, @DefaultExecutor).event
-      end
-
-      # @!macro promises.shortcut.using
-      # @return [self]
-      def on_fulfillment(*args, &callback)
-        on_fulfillment_using @DefaultExecutor, *args, &callback
-      end
-
-      # Stores the callback to be executed synchronously on resolving thread after it is
-      # fulfilled. Does nothing on rejection.
-      #
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      # @yield [value, *args] to the callback.
-      def on_fulfillment!(*args, &callback)
-        add_callback :callback_on_fulfillment, args, callback
-      end
-
-      # Stores the callback to be executed asynchronously on executor after it is
-      # fulfilled. Does nothing on rejection.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      # @yield [value, *args] to the callback.
-      def on_fulfillment_using(executor, *args, &callback)
-        add_callback :async_callback_on_fulfillment, executor, args, callback
-      end
-
-      # @!macro promises.shortcut.using
-      # @return [self]
-      def on_rejection(*args, &callback)
-        on_rejection_using @DefaultExecutor, *args, &callback
-      end
-
-      # Stores the callback to be executed synchronously on resolving thread after it is
-      # rejected. Does nothing on fulfillment.
-      #
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      # @yield [reason, *args] to the callback.
-      def on_rejection!(*args, &callback)
-        add_callback :callback_on_rejection, args, callback
-      end
-
-      # Stores the callback to be executed asynchronously on executor after it is
-      # rejected. Does nothing on fulfillment.
-      #
-      # @!macro promises.param.executor
-      # @!macro promises.param.args
-      # @!macro promise.param.callback
-      # @return [self]
-      # @yield [reason, *args] to the callback.
-      def on_rejection_using(executor, *args, &callback)
-        add_callback :async_callback_on_rejection, executor, args, callback
-      end
-
-      # Allows to use futures as green threads. The receiver has to evaluate to a future which
-      # represents what should be done next. It basically flattens indefinitely until non Future
-      # values is returned which becomes result of the returned future. Any encountered exception
-      # will become reason of the returned future.
-      #
-      # @return [Future]
-      # @param [#call(value)] run_test
-      #   an object which when called returns either Future to keep running with
-      #   or nil, then the run completes with the value.
-      #   The run_test can be used to extract the Future from deeper structure,
-      #   or to distinguish Future which is a resulting value from a future
-      #   which is suppose to continue running.
-      # @example
-      #   body = lambda do |v|
-      #     v += 1
-      #     v < 5 ? Promises.future(v, &body) : v
-      #   end
-      #   Promises.future(0, &body).run.value! # => 5
-      def run(run_test = method(:run_test))
-        RunFuturePromise.new_blocked_by1(self, @DefaultExecutor, run_test).future
-      end
-
-      # @!visibility private
-      def apply(args, block)
-        internal_state.apply args, block
-      end
-
-      # Converts future to event which is resolved when future is resolved by fulfillment or rejection.
-      #
-      # @return [Event]
-      def to_event
-        event = Promises.resolvable_event
-      ensure
-        chain_resolvable(event)
-      end
-
-      # Returns self, since this is a future
-      # @return [Future]
-      def to_future
-        self
-      end
-
-      # @return [String] Short string representation.
-      def to_s
-        if resolved?
-          format '%s with %s>', super[0..-2], (fulfilled? ? value : reason).inspect
-        else
-          super
-        end
-      end
-
-      alias_method :inspect, :to_s
-
-      private
-
-      def run_test(v)
-        v if v.is_a?(Future)
-      end
-
-      def rejected_resolution(raise_on_reassign, state)
-        if raise_on_reassign
-          if internal_state == RESERVED
-            raise Concurrent::MultipleAssignmentError.new(
-                "Future can be resolved only once. It is already reserved.")
-          else
-            raise Concurrent::MultipleAssignmentError.new(
-                "Future can be resolved only once. It's #{result}, trying to set #{state.result}.",
-                current_result: result,
-                new_result:     state.result)
-          end
-        end
-        return false
-      end
-
-      def wait_until_resolved!(timeout = nil)
-        result = wait_until_resolved(timeout)
-        raise self if rejected?
-        result
-      end
-
-      def async_callback_on_fulfillment(state, executor, args, callback)
-        with_async(executor, state, args, callback) do |st, ar, cb|
-          callback_on_fulfillment st, ar, cb
-        end
-      end
-
-      def async_callback_on_rejection(state, executor, args, callback)
-        with_async(executor, state, args, callback) do |st, ar, cb|
-          callback_on_rejection st, ar, cb
-        end
-      end
-
-      def callback_on_fulfillment(state, args, callback)
-        state.apply args, callback if state.fulfilled?
-      end
-
-      def callback_on_rejection(state, args, callback)
-        state.apply args, callback unless state.fulfilled?
-      end
-
-      def callback_on_resolution(state, args, callback)
-        callback.call(*state.result, *args)
-      end
-
-    end
-
-    # Marker module of Future, Event resolved manually.
-    module Resolvable
-      include InternalStates
-    end
-
-    # A Event which can be resolved by user.
-    class ResolvableEvent < Event
-      include Resolvable
-
-      # @!macro raise_on_reassign
-      # @raise [MultipleAssignmentError] when already resolved and raise_on_reassign is true.
-
-      # @!macro promise.param.raise_on_reassign
-      #   @param [Boolean] raise_on_reassign should method raise exception if already resolved
-      #   @return [self, false] false is returned when raise_on_reassign is false and the receiver
-      #     is already resolved.
-      #
-
-      # Makes the event resolved, which triggers all dependent futures.
-      #
-      # @!macro promise.param.raise_on_reassign
-      # @!macro promise.param.reserved
-      #   @param [true, false] reserved
-      #     Set to true if the resolvable is {#reserve}d by you,
-      #     marks resolution of reserved resolvable events and futures explicitly.
-      #     Advanced feature, ignore unless you use {Resolvable#reserve} from edge.
-      def resolve(raise_on_reassign = true, reserved = false)
-        resolve_with RESOLVED, raise_on_reassign, reserved
-      end
-
-      # Creates new event wrapping receiver, effectively hiding the resolve method.
-      #
-      # @return [Event]
-      def with_hidden_resolvable
-        @with_hidden_resolvable ||= EventWrapperPromise.new_blocked_by1(self, @DefaultExecutor).event
-      end
-
-      # Behaves as {AbstractEventFuture#wait} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @param [true, false] resolve_on_timeout
-      #   If it times out and the argument is true it will also resolve the event.
-      # @return [self, true, false]
-      # @see AbstractEventFuture#wait
-      def wait(timeout = nil, resolve_on_timeout = false)
-        super(timeout) or if resolve_on_timeout
-                            # if it fails to resolve it was resolved in the meantime
-                            # so return true as if there was no timeout
-                            !resolve(false)
-                          else
-                            false
-                          end
-      end
-    end
-
-    # A Future which can be resolved by user.
-    class ResolvableFuture < Future
-      include Resolvable
-
-      # Makes the future resolved with result of triplet `fulfilled?`, `value`, `reason`,
-      # which triggers all dependent futures.
-      #
-      # @param [true, false] fulfilled
-      # @param [Object] value
-      # @param [Object] reason
-      # @!macro promise.param.raise_on_reassign
-      # @!macro promise.param.reserved
-      def resolve(fulfilled = true, value = nil, reason = nil, raise_on_reassign = true, reserved = false)
-        resolve_with(fulfilled ? Fulfilled.new(value) : Rejected.new(reason), raise_on_reassign, reserved)
-      end
-
-      # Makes the future fulfilled with `value`,
-      # which triggers all dependent futures.
-      #
-      # @param [Object] value
-      # @!macro promise.param.raise_on_reassign
-      # @!macro promise.param.reserved
-      def fulfill(value, raise_on_reassign = true, reserved = false)
-        resolve_with Fulfilled.new(value), raise_on_reassign, reserved
-      end
-
-      # Makes the future rejected with `reason`,
-      # which triggers all dependent futures.
-      #
-      # @param [Object] reason
-      # @!macro promise.param.raise_on_reassign
-      # @!macro promise.param.reserved
-      def reject(reason, raise_on_reassign = true, reserved = false)
-        resolve_with Rejected.new(reason), raise_on_reassign, reserved
-      end
-
-      # Evaluates the block and sets its result as future's value fulfilling, if the block raises
-      # an exception the future rejects with it.
-      #
-      # @yield [*args] to the block.
-      # @yieldreturn [Object] value
-      # @return [self]
-      def evaluate_to(*args, &block)
-        promise.evaluate_to(*args, block)
-      end
-
-      # Evaluates the block and sets its result as future's value fulfilling, if the block raises
-      # an exception the future rejects with it.
-      #
-      # @yield [*args] to the block.
-      # @yieldreturn [Object] value
-      # @return [self]
-      # @raise [Exception] also raise reason on rejection.
-      def evaluate_to!(*args, &block)
-        promise.evaluate_to(*args, block).wait!
-      end
-
-      # @!macro promises.resolvable.resolve_on_timeout
-      #   @param [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] resolve_on_timeout
-      #     If it times out and the argument is not nil it will also resolve the future
-      #     to the provided resolution.
-
-      # Behaves as {AbstractEventFuture#wait} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [self, true, false]
-      # @see AbstractEventFuture#wait
-      def wait(timeout = nil, resolve_on_timeout = nil)
-        super(timeout) or if resolve_on_timeout
-                            # if it fails to resolve it was resolved in the meantime
-                            # so return true as if there was no timeout
-                            !resolve(*resolve_on_timeout, false)
-                          else
-                            false
-                          end
-      end
-
-      # Behaves as {Future#wait!} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [self, true, false]
-      # @raise [Exception] {#reason} on rejection
-      # @see Future#wait!
-      def wait!(timeout = nil, resolve_on_timeout = nil)
-        super(timeout) or if resolve_on_timeout
-                            if resolve(*resolve_on_timeout, false)
-                              false
-                            else
-                              # if it fails to resolve it was resolved in the meantime
-                              # so return true as if there was no timeout
-                              raise self if rejected?
-                              true
-                            end
-                          else
-                            false
-                          end
-      end
-
-      # Behaves as {Future#value} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [Object, timeout_value, nil]
-      # @see Future#value
-      def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil)
-        if wait_until_resolved timeout
-          internal_state.value
-        else
-          if resolve_on_timeout
-            unless resolve(*resolve_on_timeout, false)
-              # if it fails to resolve it was resolved in the meantime
-              # so return value as if there was no timeout
-              return internal_state.value
-            end
-          end
-          timeout_value
-        end
-      end
-
-      # Behaves as {Future#value!} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [Object, timeout_value, nil]
-      # @raise [Exception] {#reason} on rejection
-      # @see Future#value!
-      def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil)
-        if wait_until_resolved! timeout
-          internal_state.value
-        else
-          if resolve_on_timeout
-            unless resolve(*resolve_on_timeout, false)
-              # if it fails to resolve it was resolved in the meantime
-              # so return value as if there was no timeout
-              raise self if rejected?
-              return internal_state.value
-            end
-          end
-          timeout_value
-        end
-      end
-
-      # Behaves as {Future#reason} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [Exception, timeout_value, nil]
-      # @see Future#reason
-      def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil)
-        if wait_until_resolved timeout
-          internal_state.reason
-        else
-          if resolve_on_timeout
-            unless resolve(*resolve_on_timeout, false)
-              # if it fails to resolve it was resolved in the meantime
-              # so return value as if there was no timeout
-              return internal_state.reason
-            end
-          end
-          timeout_value
-        end
-      end
-
-      # Behaves as {Future#result} but has one additional optional argument
-      # resolve_on_timeout.
-      #
-      # @!macro promises.resolvable.resolve_on_timeout
-      # @return [::Array(Boolean, Object, Exception), nil]
-      # @see Future#result
-      def result(timeout = nil, resolve_on_timeout = nil)
-        if wait_until_resolved timeout
-          internal_state.result
-        else
-          if resolve_on_timeout
-            unless resolve(*resolve_on_timeout, false)
-              # if it fails to resolve it was resolved in the meantime
-              # so return value as if there was no timeout
-              internal_state.result
-            end
-          end
-          # otherwise returns nil
-        end
-      end
-
-      # Creates new future wrapping receiver, effectively hiding the resolve method and similar.
-      #
-      # @return [Future]
-      def with_hidden_resolvable
-        @with_hidden_resolvable ||= FutureWrapperPromise.new_blocked_by1(self, @DefaultExecutor).future
-      end
-    end
-
-    # @abstract
-    # @private
-    class AbstractPromise < Synchronization::Object
-      safe_initialization!
-      include InternalStates
-
-      def initialize(future)
-        super()
-        @Future = future
-      end
-
-      def future
-        @Future
-      end
-
-      alias_method :event, :future
-
-      def default_executor
-        future.default_executor
-      end
-
-      def state
-        future.state
-      end
-
-      def touch
-      end
-
-      def to_s
-        format '%s %s>', super[0..-2], @Future
-      end
-
-      alias_method :inspect, :to_s
-
-      def delayed_because
-        nil
-      end
-
-      private
-
-      def resolve_with(new_state, raise_on_reassign = true)
-        @Future.resolve_with(new_state, raise_on_reassign)
-      end
-
-      # @return [Future]
-      def evaluate_to(*args, block)
-        resolve_with Fulfilled.new(block.call(*args))
-      rescue Exception => error
-        resolve_with Rejected.new(error)
-        raise error unless error.is_a?(StandardError)
-      end
-    end
-
-    class ResolvableEventPromise < AbstractPromise
-      def initialize(default_executor)
-        super ResolvableEvent.new(self, default_executor)
-      end
-    end
-
-    class ResolvableFuturePromise < AbstractPromise
-      def initialize(default_executor)
-        super ResolvableFuture.new(self, default_executor)
-      end
-
-      public :evaluate_to
-    end
-
-    # @abstract
-    class InnerPromise < AbstractPromise
-    end
-
-    # @abstract
-    class BlockedPromise < InnerPromise
-
-      private_class_method :new
-
-      def self.new_blocked_by1(blocker, *args, &block)
-        blocker_delayed = blocker.promise.delayed_because
-        promise         = new(blocker_delayed, 1, *args, &block)
-        blocker.add_callback_notify_blocked promise, 0
-        promise
-      end
-
-      def self.new_blocked_by2(blocker1, blocker2, *args, &block)
-        blocker_delayed1 = blocker1.promise.delayed_because
-        blocker_delayed2 = blocker2.promise.delayed_because
-        delayed          = if blocker_delayed1 && blocker_delayed2
-                             # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
-                             LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
-                           else
-                             blocker_delayed1 || blocker_delayed2
-                           end
-        promise          = new(delayed, 2, *args, &block)
-        blocker1.add_callback_notify_blocked promise, 0
-        blocker2.add_callback_notify_blocked promise, 1
-        promise
-      end
-
-      def self.new_blocked_by(blockers, *args, &block)
-        delayed = blockers.reduce(nil) { |d, f| add_delayed d, f.promise.delayed_because }
-        promise = new(delayed, blockers.size, *args, &block)
-        blockers.each_with_index { |f, i| f.add_callback_notify_blocked promise, i }
-        promise
-      end
-
-      def self.add_delayed(delayed1, delayed2)
-        if delayed1 && delayed2
-          delayed1.push delayed2
-          delayed1
-        else
-          delayed1 || delayed2
-        end
-      end
-
-      def initialize(delayed, blockers_count, future)
-        super(future)
-        @Delayed   = delayed
-        @Countdown = AtomicFixnum.new blockers_count
-      end
-
-      def on_blocker_resolution(future, index)
-        countdown  = process_on_blocker_resolution(future, index)
-        resolvable = resolvable?(countdown, future, index)
-
-        on_resolvable(future, index) if resolvable
-      end
-
-      def delayed_because
-        @Delayed
-      end
-
-      def touch
-        clear_and_propagate_touch
-      end
-
-      # for inspection only
-      def blocked_by
-        blocked_by = []
-        ObjectSpace.each_object(AbstractEventFuture) { |o| blocked_by.push o if o.blocks.include? self }
-        blocked_by
-      end
-
-      private
-
-      def clear_and_propagate_touch(stack_or_element = @Delayed)
-        return if stack_or_element.nil?
-
-        if stack_or_element.is_a? LockFreeStack
-          stack_or_element.clear_each { |element| clear_and_propagate_touch element }
-        else
-          stack_or_element.touch unless stack_or_element.nil? # if still present
-        end
-      end
-
-      # @return [true,false] if resolvable
-      def resolvable?(countdown, future, index)
-        countdown.zero?
-      end
-
-      def process_on_blocker_resolution(future, index)
-        @Countdown.decrement
-      end
-
-      def on_resolvable(resolved_future, index)
-        raise NotImplementedError
-      end
-    end
-
-    # @abstract
-    class BlockedTaskPromise < BlockedPromise
-      def initialize(delayed, blockers_count, default_executor, executor, args, &task)
-        raise ArgumentError, 'no block given' unless block_given?
-        super delayed, 1, Future.new(self, default_executor)
-        @Executor = executor
-        @Task     = task
-        @Args     = args
-      end
-
-      def executor
-        @Executor
-      end
-    end
-
-    class ThenPromise < BlockedTaskPromise
-      private
-
-      def initialize(delayed, blockers_count, default_executor, executor, args, &task)
-        super delayed, blockers_count, default_executor, executor, args, &task
-      end
-
-      def on_resolvable(resolved_future, index)
-        if resolved_future.fulfilled?
-          Concurrent.executor(@Executor).post(resolved_future, @Args, @Task) do |future, args, task|
-            evaluate_to lambda { future.apply args, task }
-          end
-        else
-          resolve_with resolved_future.internal_state
-        end
-      end
-    end
-
-    class RescuePromise < BlockedTaskPromise
-      private
-
-      def initialize(delayed, blockers_count, default_executor, executor, args, &task)
-        super delayed, blockers_count, default_executor, executor, args, &task
-      end
-
-      def on_resolvable(resolved_future, index)
-        if resolved_future.rejected?
-          Concurrent.executor(@Executor).post(resolved_future, @Args, @Task) do |future, args, task|
-            evaluate_to lambda { future.apply args, task }
-          end
-        else
-          resolve_with resolved_future.internal_state
-        end
-      end
-    end
-
-    class ChainPromise < BlockedTaskPromise
-      private
-
-      def on_resolvable(resolved_future, index)
-        if Future === resolved_future
-          Concurrent.executor(@Executor).post(resolved_future, @Args, @Task) do |future, args, task|
-            evaluate_to(*future.result, *args, task)
-          end
-        else
-          Concurrent.executor(@Executor).post(@Args, @Task) do |args, task|
-            evaluate_to(*args, task)
-          end
-        end
-      end
-    end
-
-    # will be immediately resolved
-    class ImmediateEventPromise < InnerPromise
-      def initialize(default_executor)
-        super Event.new(self, default_executor).resolve_with(RESOLVED)
-      end
-    end
-
-    class ImmediateFuturePromise < InnerPromise
-      def initialize(default_executor, fulfilled, value, reason)
-        super Future.new(self, default_executor).
-            resolve_with(fulfilled ? Fulfilled.new(value) : Rejected.new(reason))
-      end
-    end
-
-    class AbstractFlatPromise < BlockedPromise
-
-      def initialize(delayed_because, blockers_count, event_or_future)
-        delayed = LockFreeStack.of1(self)
-        super(delayed, blockers_count, event_or_future)
-        # noinspection RubyArgCount
-        @Touched        = AtomicBoolean.new false
-        @DelayedBecause = delayed_because || LockFreeStack.new
-
-        event_or_future.add_callback_clear_delayed_node delayed.peek
-      end
-
-      def touch
-        if @Touched.make_true
-          clear_and_propagate_touch @DelayedBecause
-        end
-      end
-
-      private
-
-      def touched?
-        @Touched.value
-      end
-
-      def on_resolvable(resolved_future, index)
-        resolve_with resolved_future.internal_state
-      end
-
-      def resolvable?(countdown, future, index)
-        !@Future.internal_state.resolved? && super(countdown, future, index)
-      end
-
-      def add_delayed_of(future)
-        delayed = future.promise.delayed_because
-        if touched?
-          clear_and_propagate_touch delayed
-        else
-          BlockedPromise.add_delayed @DelayedBecause, delayed
-          clear_and_propagate_touch @DelayedBecause if touched?
-        end
-      end
-
-    end
-
-    class FlatEventPromise < AbstractFlatPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, 2, Event.new(self, default_executor)
-      end
-
-      def process_on_blocker_resolution(future, index)
-        countdown = super(future, index)
-        if countdown.nonzero?
-          internal_state = future.internal_state
-
-          unless internal_state.fulfilled?
-            resolve_with RESOLVED
-            return countdown
-          end
-
-          value = internal_state.value
-          case value
-          when AbstractEventFuture
-            add_delayed_of value
-            value.add_callback_notify_blocked self, nil
-            countdown
-          else
-            resolve_with RESOLVED
-          end
-        end
-        countdown
-      end
-
-    end
-
-    class FlatFuturePromise < AbstractFlatPromise
-
-      private
-
-      def initialize(delayed, blockers_count, levels, default_executor)
-        raise ArgumentError, 'levels has to be higher than 0' if levels < 1
-        # flat promise may result to a future having delayed futures, therefore we have to have empty stack
-        # to be able to add new delayed futures
-        super delayed || LockFreeStack.new, 1 + levels, Future.new(self, default_executor)
-      end
-
-      def process_on_blocker_resolution(future, index)
-        countdown = super(future, index)
-        if countdown.nonzero?
-          internal_state = future.internal_state
-
-          unless internal_state.fulfilled?
-            resolve_with internal_state
-            return countdown
-          end
-
-          value = internal_state.value
-          case value
-          when AbstractEventFuture
-            add_delayed_of value
-            value.add_callback_notify_blocked self, nil
-            countdown
-          else
-            evaluate_to(lambda { raise TypeError, "returned value #{value.inspect} is not a Future" })
-          end
-        end
-        countdown
-      end
-
-    end
-
-    class RunFuturePromise < AbstractFlatPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor, run_test)
-        super delayed, 1, Future.new(self, default_executor)
-        @RunTest = run_test
-      end
-
-      def process_on_blocker_resolution(future, index)
-        internal_state = future.internal_state
-
-        unless internal_state.fulfilled?
-          resolve_with internal_state
-          return 0
-        end
-
-        value               = internal_state.value
-        continuation_future = @RunTest.call value
-
-        if continuation_future
-          add_delayed_of continuation_future
-          continuation_future.add_callback_notify_blocked self, nil
-        else
-          resolve_with internal_state
-        end
-
-        1
-      end
-    end
-
-    class ZipEventEventPromise < BlockedPromise
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, 2, Event.new(self, default_executor)
-      end
-
-      private
-
-      def on_resolvable(resolved_future, index)
-        resolve_with RESOLVED
-      end
-    end
-
-    class ZipFutureEventPromise < BlockedPromise
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, 2, Future.new(self, default_executor)
-        @result = nil
-      end
-
-      private
-
-      def process_on_blocker_resolution(future, index)
-        # first blocking is future, take its result
-        @result = future.internal_state if index == 0
-        # super has to be called after above to piggyback on volatile @Countdown
-        super future, index
-      end
-
-      def on_resolvable(resolved_future, index)
-        resolve_with @result
-      end
-    end
-
-    class EventWrapperPromise < BlockedPromise
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, 1, Event.new(self, default_executor)
-      end
-
-      private
-
-      def on_resolvable(resolved_future, index)
-        resolve_with RESOLVED
-      end
-    end
-
-    class FutureWrapperPromise < BlockedPromise
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, 1, Future.new(self, default_executor)
-      end
-
-      private
-
-      def on_resolvable(resolved_future, index)
-        resolve_with resolved_future.internal_state
-      end
-    end
-
-    class ZipFuturesPromise < BlockedPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor)
-        super(delayed, blockers_count, Future.new(self, default_executor))
-        @Resolutions = ::Array.new(blockers_count, nil)
-
-        on_resolvable nil, nil if blockers_count == 0
-      end
-
-      def process_on_blocker_resolution(future, index)
-        # TODO (pitr-ch 18-Dec-2016): Can we assume that array will never break under parallel access when never re-sized?
-        @Resolutions[index] = future.internal_state # has to be set before countdown in super
-        super future, index
-      end
-
-      def on_resolvable(resolved_future, index)
-        all_fulfilled = true
-        values        = ::Array.new(@Resolutions.size)
-        reasons       = ::Array.new(@Resolutions.size)
-
-        @Resolutions.each_with_index do |internal_state, i|
-          fulfilled, values[i], reasons[i] = internal_state.result
-          all_fulfilled                    &&= fulfilled
-        end
-
-        if all_fulfilled
-          resolve_with FulfilledArray.new(values)
-        else
-          resolve_with PartiallyRejected.new(values, reasons)
-        end
-      end
-    end
-
-    class ZipEventsPromise < BlockedPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, blockers_count, Event.new(self, default_executor)
-
-        on_resolvable nil, nil if blockers_count == 0
-      end
-
-      def on_resolvable(resolved_future, index)
-        resolve_with RESOLVED
-      end
-    end
-
-    # @abstract
-    class AbstractAnyPromise < BlockedPromise
-    end
-
-    class AnyResolvedEventPromise < AbstractAnyPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, blockers_count, Event.new(self, default_executor)
-      end
-
-      def resolvable?(countdown, future, index)
-        true
-      end
-
-      def on_resolvable(resolved_future, index)
-        resolve_with RESOLVED, false
-      end
-    end
-
-    class AnyResolvedFuturePromise < AbstractAnyPromise
-
-      private
-
-      def initialize(delayed, blockers_count, default_executor)
-        super delayed, blockers_count, Future.new(self, default_executor)
-      end
-
-      def resolvable?(countdown, future, index)
-        true
-      end
-
-      def on_resolvable(resolved_future, index)
-        resolve_with resolved_future.internal_state, false
-      end
-    end
-
-    class AnyFulfilledFuturePromise < AnyResolvedFuturePromise
-
-      private
-
-      def resolvable?(countdown, event_or_future, index)
-        (event_or_future.is_a?(Event) ? event_or_future.resolved? : event_or_future.fulfilled?) ||
-            # inlined super from BlockedPromise
-            countdown.zero?
-      end
-    end
-
-    class DelayPromise < InnerPromise
-
-      def initialize(default_executor)
-        event    = Event.new(self, default_executor)
-        @Delayed = LockFreeStack.of1(self)
-        super event
-        event.add_callback_clear_delayed_node @Delayed.peek
-      end
-
-      def touch
-        @Future.resolve_with RESOLVED
-      end
-
-      def delayed_because
-        @Delayed
-      end
-
-    end
-
-    class ScheduledPromise < InnerPromise
-      def intended_time
-        @IntendedTime
-      end
-
-      def inspect
-        "#{to_s[0..-2]} intended_time: #{@IntendedTime}>"
-      end
-
-      private
-
-      def initialize(default_executor, intended_time)
-        super Event.new(self, default_executor)
-
-        @IntendedTime = intended_time
-
-        in_seconds = begin
-          now           = Time.now
-          schedule_time = if @IntendedTime.is_a? Time
-                            @IntendedTime
-                          else
-                            now + @IntendedTime
-                          end
-          [0, schedule_time.to_f - now.to_f].max
-        end
-
-        Concurrent.global_timer_set.post(in_seconds) do
-          @Future.resolve_with RESOLVED
-        end
-      end
-    end
-
-    extend FactoryMethods
-
-    private_constant :AbstractPromise,
-                     :ResolvableEventPromise,
-                     :ResolvableFuturePromise,
-                     :InnerPromise,
-                     :BlockedPromise,
-                     :BlockedTaskPromise,
-                     :ThenPromise,
-                     :RescuePromise,
-                     :ChainPromise,
-                     :ImmediateEventPromise,
-                     :ImmediateFuturePromise,
-                     :AbstractFlatPromise,
-                     :FlatFuturePromise,
-                     :FlatEventPromise,
-                     :RunFuturePromise,
-                     :ZipEventEventPromise,
-                     :ZipFutureEventPromise,
-                     :EventWrapperPromise,
-                     :FutureWrapperPromise,
-                     :ZipFuturesPromise,
-                     :ZipEventsPromise,
-                     :AbstractAnyPromise,
-                     :AnyResolvedFuturePromise,
-                     :AnyFulfilledFuturePromise,
-                     :AnyResolvedEventPromise,
-                     :DelayPromise,
-                     :ScheduledPromise
-
-
-  end
-end