concurrent-ruby-edge 0.1.0.pre2 → 0.1.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21429b1dcafe35b79201be08fd02442171fc68fb
-  data.tar.gz: 2de92c445f74fbf670cb605e760b9a4c413597c4
+  metadata.gz: b3b0a6f42dd53529fb35370f6d9d6b1957aa576c
+  data.tar.gz: b960e25b2834254aaa00685cf38e41fc3a481e9f
 SHA512:
-  metadata.gz: cb45d38d9f966ff005121fec47adc053349675ee7d018662e7b49c67a67fdd3c3bb603cca559d3b39c4243f62ff099905c72b320b2ada6b29d8d5fc00541df49
-  data.tar.gz: 2e1c9c51ec89bb08e32ced3883cf5fa8cf472bdf0a98616af1966e7929c2c018ee832b747262fff13831295aa381c67cf883f207f60c9dfa29355c504803563d
+  metadata.gz: aec6112c612dbfa9f709181cef273ba892ae5db92915875e7750d18e159c821e613f5c02520530eb27805e60531e55e68021ac003279a94b8d78b63ef184948e
+  data.tar.gz: bb59836fc4e5da39fc2c3f7885d1a123f0a9100850c9c486871830d9421c5b2e0756f45e9f7c7dee7f538adfd030f765b3a54fa33fd94726c13e05b8d08b4977

data/lib/concurrent/actor/utils/pool.rb

@@ -12,14 +12,14 @@ module Concurrent
       # @yieldparam [Integer] index of the worker, usually used in its name
       # @yieldreturn [Reference] the reference of newly created worker
       # @example
-      #     class Worker < Concurrent::Actor::Utils::AbstractWorker
-      #       def work(message)
+      #     class Worker < Concurrent::Actor::RestartingContext
+      #       def on_message(message)
       #         p message * 5
       #       end
       #     end
       #
-      #     pool = Concurrent::Actor::Utils::Pool.spawn! 'pool', 5 do |balancer, index|
-      #       Worker.spawn name: "worker-#{index}", supervise: true, args: [balancer]
+      #     pool = Concurrent::Actor::Utils::Pool.spawn! 'pool', 5 do |index|
+      #       Worker.spawn name: "worker-#{index}", supervise: true, args: []
       #     end
       #
       #     pool << 'asd' << 2

data/lib/concurrent/agent.rb

@@ -93,15 +93,7 @@ module Concurrent
     #
     # @param [Object] initial the initial value
     #
-    # @!macro [attach] executor_and_deref_options
-    #  
-    #   @param [Hash] opts the options used to define the behavior at update and deref
-    #     and to specify the executor on which to perform actions
-    #   @option opts [Executor] :executor when set use the given `Executor` instance.
-    #     Three special values are also supported: `:task` returns the global task pool,
-    #     `:operation` returns the global operation pool, and `:immediate` returns a new
-    #     `ImmediateExecutor` object.
-    #   @!macro deref_options
+    # @!macro executor_and_deref_options
     def initialize(initial, opts = {})
       @value                = initial
       @rescuers             = []

data/lib/concurrent/edge/future.rb

@@ -31,42 +31,38 @@ module Concurrent
       # @overload future(default_executor = :io)
       #   User is responsible for completing the future once by {Edge::CompletableFuture#success} or {Edge::CompletableFuture#fail}
       #   @return [CompletableFuture]
-      def future(*args, &task)
-        future_on :io, *args, &task
-      end
-
-      def future_on(default_executor, *args, &task)
+      def future(default_executor = :io, &task)
         if task
-          ImmediatePromise.new(default_executor, *args).future.then(&task)
+          ImmediateEventPromise.new(default_executor).future.then(&task)
         else
           CompletableFuturePromise.new(default_executor).future
         end
       end
 
+      # @return [Future] which is already completed with value
+      def completed_future(value, default_executor = :io)
+        ImmediateFuturePromise.new(default_executor, value).future
+      end
+
+      # @return [Event] which is already completed
+      def completed_event(default_executor = :io)
+        ImmediateEventPromise.new(default_executor).event
+      end
+
       alias_method :async, :future
 
       # Constructs new Future which will evaluate to the block after
       # requested by calling `#wait`, `#value`, `#value!`, etc. on it or on any of the chained futures.
       # @return [Future]
-      def delay(*args, &task)
-        delay_on :io, *args, &task
-      end
-
-      # @return [Future]
-      def delay_on(default_executor, *args, &task)
-        Delay.new(default_executor, *args).future.then(&task)
+      def delay(default_executor = :io, &task)
+        Delay.new(default_executor).future.then(&task)
       end
 
       # Schedules the block to be executed on executor in given intended_time.
       # @param [Numeric, Time] intended_time Numeric => run in `intended_time` seconds. Time => eun on time.
       # @return [Future]
-      def schedule(intended_time, *args, &task)
-        schedule_on :io, intended_time, *args, &task
-      end
-
-      # @return [Future]
-      def schedule_on(default_executor, intended_time, *args, &task)
-        ScheduledPromise.new(default_executor, intended_time, *args).future.then(&task)
+      def schedule(intended_time, default_executor = :io, &task)
+        ScheduledPromise.new(default_executor, intended_time).future.then(&task)
       end
 
       # Constructs new {Future} which is completed after all futures are complete. Its value is array
@@ -74,7 +70,7 @@ module Concurrent
       # @param [Event] futures
       # @return [Future]
       def zip(*futures)
-        AllPromise.new(futures, :io).future
+        ZipPromise.new(futures, :io).future
       end
 
       # Constructs new {Future} which is completed after first of the futures is complete.
@@ -121,6 +117,7 @@ module Concurrent
     class Event < Synchronization::Object
       include Concern::Deprecation
 
+      # @!visibility private
       class State
         def completed?
           raise NotImplementedError
@@ -131,6 +128,7 @@ module Concurrent
         end
       end
 
+      # @!visibility private
       class Pending < State
         def completed?
           false
@@ -141,6 +139,7 @@ module Concurrent
         end
       end
 
+      # @!visibility private
       class Completed < State
         def completed?
           true
@@ -151,7 +150,9 @@ module Concurrent
         end
       end
 
+      # @!visibility private
       PENDING   = Pending.new
+      # @!visibility private
       COMPLETED = Completed.new
 
       def initialize(promise, default_executor)
@@ -159,7 +160,7 @@ module Concurrent
         @DefaultExecutor = default_executor
         @Touched         = AtomicBoolean.new(false)
         @Callbacks       = LockFreeStack.new
-        @Waiters         = LockFreeStack.new
+        @Waiters         = LockFreeStack.new # TODO replace with AtomicFixnum, avoid aba problem
         @State           = AtomicReference.new PENDING
         super()
         ensure_ivar_visibility!
@@ -192,11 +193,14 @@ module Concurrent
 
       # Wait until Event is #complete?
       # @param [Numeric] timeout the maximum time in second to wait.
-      # @return [Event] self
+      # @return [Event, true, false] self or true/false if timeout is used
+      # @!macro [attach] edge.periodical_wait
+      #   @note a thread should wait only once! For repeated checking use faster `completed?` check.
+      #     If thread waits periodically it will dangerously grow the waiters stack.
       def wait(timeout = nil)
         touch
-        wait_until_complete timeout
-        self
+        result = wait_until_complete(timeout)
+        timeout ? result : self
       end
 
       # @!visibility private
@@ -219,31 +223,44 @@ module Concurrent
 
       alias_method :then, :chain
 
-      # TODO take block optionally
-      # Zip with futures producing new Future
-      # @return [Future]
-      def zip(*futures)
-        AllPromise.new([self, *futures], @DefaultExecutor).future
+      def chain_completable(completable_event)
+        on_completion! { completable_event.complete_with COMPLETED }
+      end
+
+      alias_method :tangle, :chain_completable
+
+      # Zip with future producing new Future
+      # @return [Event]
+      def zip(other)
+        if other.is?(Future)
+          ZipFutureEventPromise.new(other, self, @DefaultExecutor).future
+        else
+          ZipEventEventPromise.new(self, other, @DefaultExecutor).future
+        end
       end
 
       alias_method :&, :zip
 
       # Inserts delay into the chain of Futures making rest of it lazy evaluated.
-      # @return [Future]
+      # @return [Event]
       def delay
-        zip(Delay.new(@DefaultExecutor).future)
+        ZipEventEventPromise.new(self, Delay.new(@DefaultExecutor).event, @DefaultExecutor).event
       end
 
-      # Schedules rest of the chain for execution with specified time or on specified time
-      # @return [Future]
-      def schedule(intended_time)
-        chain { ScheduledPromise.new(@DefaultExecutor, intended_time).event.zip(self) }.flat
-      end
+      # # Schedules rest of the chain for execution with specified time or on specified time
+      # # @return [Event]
+      # def schedule(intended_time)
+      #   chain do
+      #     ZipEventEventPromise.new(self,
+      #                              ScheduledPromise.new(@DefaultExecutor, intended_time).event,
+      #                              @DefaultExecutor).event
+      #   end.flat
+      # end
 
       # Zips with selected value form the suplied channels
       # @return [Future]
       def then_select(*channels)
-        self.zip(Concurrent.select(*channels))
+        ZipFutureEventPromise(Concurrent.select(*channels), self, @DefaultExecutor).future
       end
 
       # @yield [success, value, reason] executed async on `executor` when completed
@@ -259,9 +276,9 @@ module Concurrent
       end
 
       # Changes default executor for rest of the chain
-      # @return [Future]
+      # @return [Event]
       def with_default_executor(executor)
-        AllPromise.new([self], executor).future
+        EventWrapperPromise.new(self, executor).future
       end
 
       def to_s
@@ -278,13 +295,14 @@ module Concurrent
       end
 
       # @!visibility private
-      def complete(raise_on_reassign = true)
-        if complete_state
+      def complete_with(state, raise_on_reassign = true)
+        if @State.compare_and_set(PENDING, state)
+          (state)
           # go to synchronized block only if there were waiting threads
           synchronize { ns_broadcast } if @Waiters.clear
           call_callbacks
         else
-          Concurrent::MultipleAssignmentError.new('multiple assignment') if raise_on_reassign
+          Concurrent::MultipleAssignmentError.new('Event can be completed only once') if raise_on_reassign
           return false
         end
         self
@@ -328,31 +346,32 @@ module Concurrent
         @Touched.value
       end
 
+      # @!visibility private
       # only for debugging inspection
       def waiting_threads
         @Waiters.each.to_a
       end
 
+      # @!visibility private
+      def internal_state
+        @State.get
+      end
+
       private
 
+      # @return [true, false]
       def wait_until_complete(timeout)
         while true
           last_waiter = @Waiters.peek # waiters' state before completion
-          break if completed?
+          return true if completed?
 
           # synchronize so it cannot be signaled before it waits
           synchronize do
             # ok only if completing thread did not start signaling
             next unless @Waiters.compare_and_push last_waiter, Thread.current
-            ns_wait_until(timeout) { completed? }
-            break
+            return ns_wait_until(timeout) { completed? }
           end
         end
-        self
-      end
-
-      def complete_state
-        COMPLETED if @State.compare_and_set(PENDING, COMPLETED)
       end
 
       def pr_with_async(executor, *args, &block)
@@ -386,6 +405,7 @@ module Concurrent
 
     # Represents a value which will become available in future. May fail with a reason instead.
     class Future < Event
+      # @!visibility private
       class CompletedWithResult < Completed
         def result
           [success?, value, reason]
@@ -404,6 +424,7 @@ module Concurrent
         end
       end
 
+      # @!visibility private
       class Success < CompletedWithResult
         def initialize(value)
           @Value = value
@@ -430,12 +451,14 @@ module Concurrent
         end
       end
 
+      # @!visibility private
       class SuccessArray < Success
         def apply(block)
           block.call *value
         end
       end
 
+      # @!visibility private
       class Failed < CompletedWithResult
         def initialize(reason)
           @Reason = reason
@@ -456,6 +479,39 @@ module Concurrent
         def to_sym
           :failed
         end
+
+        def apply(block)
+          block.call reason
+        end
+      end
+
+      # @!visibility private
+      class PartiallyFailed < CompletedWithResult
+        def initialize(value, reason)
+          @Value  = value
+          @Reason = reason
+          super()
+        end
+
+        def success?
+          false
+        end
+
+        def to_sym
+          :failed
+        end
+
+        def value
+          @Value
+        end
+
+        def reason
+          @Reason
+        end
+
+        def apply(block)
+          block.call *reason
+        end
       end
 
       # @!method state
@@ -464,7 +520,7 @@ module Concurrent
       # Has Future been success?
       # @return [Boolean]
       def success?(state = @State.get)
-        state.success?
+        state.completed? && state.success?
       end
 
       def fulfilled?
@@ -475,7 +531,7 @@ module Concurrent
       # Has Future been failed?
       # @return [Boolean]
       def failed?(state = @State.get)
-        !success?(state)
+        state.completed? && !state.success?
       end
 
       def rejected?
@@ -483,52 +539,65 @@ module Concurrent
         failed?
       end
 
-      # @return [Object] the value of the Future when success
+      # @return [Object, nil] the value of the Future when success, nil on timeout
+      # @!macro [attach] edge.timeout_nil
+      #   @note If the Future can have value `nil` then it cannot be distinquished from `nil` returned on timeout.
+      #     In this case is better to use first `wait` then `value` (or similar).
+      # @!macro edge.periodical_wait
       def value(timeout = nil)
         touch
-        wait_until_complete timeout
-        @State.get.value
+        @State.get.value if wait_until_complete timeout
       end
 
-      # @return [Exception] the reason of the Future's failure
+      # @return [Exception, nil] the reason of the Future's failure
+      # @!macro edge.timeout_nil
+      # @!macro edge.periodical_wait
       def reason(timeout = nil)
         touch
-        wait_until_complete timeout
-        @State.get.reason
+        @State.get.reason if wait_until_complete timeout
       end
 
-      # @return [Array(Boolean, Object, Exception)] triplet of success, value, reason
+      # @return [Array(Boolean, Object, Exception), nil] triplet of success, value, reason
+      # @!macro edge.timeout_nil
+      # @!macro edge.periodical_wait
       def result(timeout = nil)
         touch
-        wait_until_complete timeout
-        @State.get.result
+        @State.get.result if wait_until_complete timeout
       end
 
       # Wait until Future is #complete?
       # @param [Numeric] timeout the maximum time in second to wait.
       # @raise reason on failure
-      # @return [Event] self
+      # @return [Event, true, false] self or true/false if timeout is used
+      # @!macro edge.periodical_wait
       def wait!(timeout = nil)
         touch
-        wait_until_complete! timeout
+        result = wait_until_complete!(timeout)
+        timeout ? result : self
       end
 
       # Wait until Future is #complete?
       # @param [Numeric] timeout the maximum time in second to wait.
       # @raise reason on failure
-      # @return [Object]
+      # @return [Object, nil]
+      # @!macro edge.timeout_nil
+      # @!macro edge.periodical_wait
       def value!(timeout = nil)
         touch
-        wait_until_complete!(timeout)
-        @State.get.value
+        @State.get.value if wait_until_complete! timeout
       end
 
       # @example allows failed Future to be risen
       #   raise Concurrent.future.fail
       def exception(*args)
-        touch
         raise 'obligation is not failed' unless failed?
-        @State.get.reason.exception(*args)
+        reason = @State.get.reason
+        if reason.is_a?(Array)
+          reason.each { |e| log Error, 'Edge::Future', e }
+          Concurrent::Error.new 'multiple exceptions, inspect log'
+        else
+          reason.exception(*args)
+        end
       end
 
       # @yield [value] executed only on parent success
@@ -543,6 +612,12 @@ module Concurrent
         self.then { |v| actor.ask(v) }.flat
       end
 
+      def chain_completable(completable_future)
+        on_completion! { completable_future.complete_with internal_state }
+      end
+
+      alias_method :tangle, :chain_completable
+
       # @yield [reason] executed only on parent failure
       # @return [Future]
       def rescue(executor = nil, &callback)
@@ -553,7 +628,7 @@ module Concurrent
       # @example
       #   Concurrent.future { Concurrent.future { 1 } }.flat.vale # => 1
       def flat(level = 1)
-        FlattingPromise.new(self, level, @DefaultExecutor).future
+        FlatPromise.new(self, level, @DefaultExecutor).future
       end
 
       # @return [Future] which has first completed value from futures
@@ -561,11 +636,52 @@ module Concurrent
         AnyPromise.new([self, *futures], @DefaultExecutor).future
       end
 
+      # Inserts delay into the chain of Futures making rest of it lazy evaluated.
+      # @return [Future]
+      def delay
+        ZipFutureEventPromise.new(self, Delay.new(@DefaultExecutor).future, @DefaultExecutor).future
+      end
+
+      # Schedules rest of the chain for execution with specified time or on specified time
+      # @return [Future]
+      def schedule(intended_time)
+        chain do
+          ZipFutureEventPromise.new(self,
+                                    ScheduledPromise.new(@DefaultExecutor, intended_time).event,
+                                    @DefaultExecutor).future
+        end.flat
+      end
+
+      # Zips with selected value form the suplied channels
+      # @return [Future]
+      def then_select(*channels)
+        ZipPromise.new([self, Concurrent.select(*channels)], @DefaultExecutor).future
+      end
+
+      # Changes default executor for rest of the chain
+      # @return [Future]
+      def with_default_executor(executor)
+        FutureWrapperPromise.new(self, executor).future
+      end
+
+      # Zip with future producing new Future
+      # @return [Future]
+      def zip(other)
+        if other.is_a?(Future)
+          ZipFutureFuturePromise.new(self, other, @DefaultExecutor).future
+        else
+          ZipFutureEventPromise.new(self, other, @DefaultExecutor).future
+        end
+      end
+
+      alias_method :&, :zip
+
       alias_method :|, :any
 
       # only proof of concept
+      # @note may block
       def then_push(channel)
-        on_success { |value| channel.push value } # FIXME it's blocking for now
+        on_success { |value| channel.push value }
       end
 
       # @yield [value] executed async on `executor` when success
@@ -593,13 +709,18 @@ module Concurrent
       end
 
       # @!visibility private
-      def complete(success, value, reason, raise_on_reassign = true)
-        if (new_state = complete_state success, value, reason)
+      def complete_with(state, raise_on_reassign = true)
+        if @State.compare_and_set(PENDING, state)
           @Waiters.clear
           synchronize { ns_broadcast }
-          call_callbacks new_state
+          call_callbacks state
         else
-          raise reason || Concurrent::MultipleAssignmentError.new('multiple assignment') if raise_on_reassign
+          if raise_on_reassign
+            log ERROR, 'Edge::Future', reason if reason # print otherwise hidden error
+            raise(Concurrent::MultipleAssignmentError.new(
+                      "Future can be completed only once. Current result is #{result}, " +
+                          "trying to set #{state.result}"))
+          end
           return false
         end
         self
@@ -627,22 +748,9 @@ module Concurrent
       private
 
       def wait_until_complete!(timeout = nil)
-        wait_until_complete(timeout)
+        result = wait_until_complete(timeout)
         raise self if failed?
-        self
-      end
-
-      def complete_state(success, value, reason)
-        new_state = if success
-                      if value.is_a?(Array)
-                        SuccessArray.new(value)
-                      else
-                        Success.new(value)
-                      end
-                    else
-                      Failed.new(reason)
-                    end
-        new_state if @State.compare_and_set(PENDING, new_state)
+        result
       end
 
       def call_callbacks(state)
@@ -697,11 +805,11 @@ module Concurrent
     class CompletableEvent < Event
       # Complete the Event, `raise` if already completed
       def complete(raise_on_reassign = true)
-        super raise_on_reassign
+        complete_with COMPLETED, raise_on_reassign
       end
 
       def hide_completable
-        Concurrent.zip(self)
+        EventWrapperPromise.new(self, @DefaultExecutor).event
       end
     end
 
@@ -711,7 +819,7 @@ module Concurrent
       # `raise` if already completed
       # return [self]
       def complete(success, value, reason, raise_on_reassign = true)
-        super success, value, reason, raise_on_reassign
+        complete_with(success ? Success.new(value) : Failed.new(reason), raise_on_reassign)
       end
 
       # Complete the future with value
@@ -752,12 +860,10 @@ module Concurrent
       end
 
       def hide_completable
-        Concurrent.zip(self)
+        FutureWrapperPromise.new(self, @DefaultExecutor).future
       end
     end
 
-    # TODO modularize blocked_by and notify blocked
-
     # @abstract
     # @!visibility private
     class AbstractPromise < Synchronization::Object
@@ -793,22 +899,20 @@ module Concurrent
 
       private
 
-      def complete(*args)
-        @Future.complete(*args)
+      def complete_with(new_state, raise_on_reassign = true)
+        @Future.complete_with(new_state, raise_on_reassign)
       end
 
       # @return [Future]
       def evaluate_to(*args, block)
-        complete true, block.call(*args), nil
+        complete_with Future::Success.new(block.call(*args))
       rescue => error
-        complete false, nil, error
+        complete_with Future::Failed.new(error)
       end
     end
 
     # @!visibility private
     class CompletableEventPromise < AbstractPromise
-      public :complete
-
       def initialize(default_executor)
         super CompletableEvent.new(self, default_executor)
       end
@@ -816,8 +920,6 @@ module Concurrent
 
     # @!visibility private
     class CompletableFuturePromise < AbstractPromise
-      # TODO consider to allow being blocked_by
-
       def initialize(default_executor)
         super CompletableFuture.new(self, default_executor)
       end
@@ -828,11 +930,11 @@ module Concurrent
       # @raise [Concurrent::MultipleAssignmentError] if the `Future` has already been set or otherwise completed
       # @return [Future]
       def success(value)
-        complete(true, value, nil)
+        complete_with Future::Success.new(value)
       end
 
       def try_success(value)
-        complete(true, value, nil, false)
+        !!complete_with(Future::Success.new(value), false)
       end
 
       # Set the `Future` to failed due to some error and wake or notify all threads waiting on it.
@@ -841,14 +943,13 @@ module Concurrent
       # @raise [Concurrent::MultipleAssignmentError] if the `Future` has already been set or otherwise completed
       # @return [Future]
       def fail(reason = StandardError.new)
-        complete(false, nil, reason)
+        complete_with Future::Failed.new(reason)
       end
 
       def try_fail(reason = StandardError.new)
-        !!complete(false, nil, reason, false)
+        !!complete_with(Future::Failed.new(reason), false)
       end
 
-      public :complete
       public :evaluate_to
 
       # @return [Future]
@@ -865,7 +966,7 @@ module Concurrent
     # @abstract
     # @!visibility private
     class BlockedPromise < InnerPromise
-      def initialize(future, blocked_by_futures, countdown, &block)
+      def initialize(future, blocked_by_futures, countdown)
         initialize_blocked_by(blocked_by_futures)
         @Countdown = AtomicFixnum.new countdown
 
@@ -956,7 +1057,7 @@ module Concurrent
             evaluate_to lambda { done_future.apply task }
           end
         else
-          complete false, nil, done_future.reason
+          complete_with Future::Failed.new(done_future.reason)
         end
       end
     end
@@ -966,15 +1067,16 @@ module Concurrent
       private
 
       def initialize(blocked_by_future, default_executor, executor, &task)
-        raise ArgumentError, 'only Future can be rescued' unless blocked_by_future.is_a? Future
         super blocked_by_future, default_executor, executor, &task
       end
 
       def on_completable(done_future)
         if done_future.failed?
-          Concurrent.post_on(@Executor, done_future.reason, @Task) { |reason, task| evaluate_to reason, task }
+          Concurrent.post_on(@Executor, done_future, @Task) do |done_future, task|
+            evaluate_to lambda { done_future.apply task }
+          end
         else
-          complete true, done_future.value, nil
+          complete_with done_future.internal_state
         end
       end
     end
@@ -994,18 +1096,21 @@ module Concurrent
 
     # will be immediately completed
     # @!visibility private
-    class ImmediatePromise < InnerPromise
-      def initialize(default_executor, *args)
-        super(if args.empty?
-                Event.new(self, default_executor).complete
-              else
-                Future.new(self, default_executor).complete(true, args, nil)
-              end)
+    class ImmediateEventPromise < InnerPromise
+      def initialize(default_executor)
+        super Event.new(self, default_executor).complete_with(Event::COMPLETED)
       end
     end
 
     # @!visibility private
-    class FlattingPromise < BlockedPromise
+    class ImmediateFuturePromise < InnerPromise
+      def initialize(default_executor, value)
+        super Future.new(self, default_executor).complete_with(Future::Success.new(value))
+      end
+    end
+
+    # @!visibility private
+    class FlatPromise < BlockedPromise
 
       # !visibility private
       def blocked_by
@@ -1034,8 +1139,6 @@ module Concurrent
 
       def initialize(blocked_by_future, levels, default_executor)
         raise ArgumentError, 'levels has to be higher than 0' if levels < 1
-        blocked_by_future.is_a? Future or
-            raise ArgumentError, 'only Future can be flatten'
         super Future.new(self, default_executor), blocked_by_future, 1 + levels
       end
 
@@ -1044,7 +1147,7 @@ module Concurrent
       end
 
       def on_completable(done_future)
-        complete *done_future.result
+        complete_with done_future.internal_state
       end
 
       def clear_blocked_by!
@@ -1054,7 +1157,73 @@ module Concurrent
     end
 
     # @!visibility private
-    class AllPromise < BlockedPromise
+    class ZipEventEventPromise < BlockedPromise
+      def initialize(event1, event2, default_executor)
+        super Event.new(self, default_executor), [event1, event2], 2
+      end
+
+      def on_completable(done_future)
+        complete_with Event::COMPLETED
+      end
+    end
+
+    # @!visibility private
+    class ZipFutureEventPromise < BlockedPromise
+      def initialize(future, event, default_executor)
+        @FutureResult = future
+        super Future.new(self, default_executor), [future, event], 2
+      end
+
+      def on_completable(done_future)
+        complete_with @FutureResult.internal_state
+      end
+    end
+
+    # @!visibility private
+    class ZipFutureFuturePromise < BlockedPromise
+      def initialize(future1, future2, default_executor)
+        @Future1Result = future1
+        @Future2Result = future2
+        super Future.new(self, default_executor), [future1, future2], 2
+      end
+
+      def on_completable(done_future)
+        success1, value1, reason1 = @Future1Result.result
+        success2, value2, reason2 = @Future2Result.result
+        success                   = success1 && success2
+        new_state                 = if success
+                                      Future::SuccessArray.new([value1, value2])
+                                    else
+                                      Future::PartiallyFailed.new([value1, value2], [reason1, reason2])
+                                    end
+        complete_with new_state
+      end
+    end
+
+    # @!visibility private
+    class EventWrapperPromise < BlockedPromise
+      def initialize(event, default_executor)
+        super Event.new(self, default_executor), event, 1
+      end
+
+      def on_completable(done_future)
+        complete_with Event::COMPLETED
+      end
+    end
+
+    # @!visibility private
+    class FutureWrapperPromise < BlockedPromise
+      def initialize(future, default_executor)
+        super Future.new(self, default_executor), future, 1
+      end
+
+      def on_completable(done_future)
+        complete_with done_future.internal_state
+      end
+    end
+
+    # @!visibility private
+    class ZipPromise < BlockedPromise
 
       private
 
@@ -1071,6 +1240,10 @@ module Concurrent
 
         # noinspection RubyArgCount
         super(klass.new(self, default_executor), blocked_by_futures, blocked_by_futures.size)
+
+        if blocked_by_futures.empty?
+          on_completable nil
+        end
       end
 
       def on_completable(done_future)
@@ -1092,13 +1265,16 @@ module Concurrent
 
         if all_success
           if values.empty?
-            complete
+            complete_with Event::COMPLETED
           else
-            complete(true, values.size == 1 ? values.first : values, nil)
+            if values.size == 1
+              complete_with Future::Success.new(values.first)
+            else
+              complete_with Future::SuccessArray.new(values)
+            end
           end
         else
-          # TODO what about other reasons?
-          complete(false, nil, reasons.compact.first)
+          complete_with Future::PartiallyFailed.new(values, reasons)
         end
       end
     end
@@ -1119,29 +1295,34 @@ module Concurrent
       end
 
       def on_completable(done_future)
-        complete *done_future.result, false
+        complete_with done_future.internal_state, false
       end
     end
 
     # @!visibility private
     class Delay < InnerPromise
       def touch
-        if @Args.empty?
-          @Future.complete
-        else
-          @Future.complete(true, @Args, nil)
-        end
+        @Future.complete_with Event::COMPLETED
       end
 
       private
 
-      def initialize(default_executor, *args)
-        @Args = args
-        super(if args.empty?
-                Event.new(self, default_executor)
-              else
-                Future.new(self, default_executor)
-              end)
+      def initialize(default_executor)
+        super Event.new(self, default_executor)
+      end
+    end
+
+    # @!visibility private
+    class DelayValue < InnerPromise
+      def touch
+        @Future.complete_with Future::Success.new(@Value)
+      end
+
+      private
+
+      def initialize(default_executor, value)
+        @Value = value
+        super Future.new(self, default_executor)
       end
     end
 
@@ -1158,7 +1339,7 @@ module Concurrent
 
       private
 
-      def initialize(default_executor, intended_time, *args)
+      def initialize(default_executor, intended_time)
         @IntendedTime = intended_time
 
         in_seconds = begin
@@ -1171,19 +1352,10 @@ module Concurrent
           [0, schedule_time.to_f - now.to_f].max
         end
 
-        use_event = args.empty?
-        super(if use_event
-                Event.new(self, default_executor)
-              else
-                Future.new(self, default_executor)
-              end)
+        super Event.new(self, default_executor)
 
-        Concurrent.global_timer_set.post(in_seconds, *args) do |*args|
-          if use_event
-            @Future.complete
-          else
-            @Future.complete(true, args, nil)
-          end
+        Concurrent.global_timer_set.post(in_seconds) do
+          @Future.complete_with Event::COMPLETED
         end
       end
     end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre2
+  version: 0.1.0.pre3
 platform: ruby
 authors:
 - Jerry D'Antonio
+- Petr Chalupa
 - The Ruby Concurrency Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2015-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -17,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0.pre2
+        version: 0.9.0.pre3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0.pre2
+        version: 0.9.0.pre3
 description: |
   These features are under active development and may change frequently. They are expected not to
   keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -102,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Edge features and additions to the concurrent-ruby gem.