Merge pull request #158 from obrok/promise-composition

Promise composition

Author: jdantonio

lib/concurrent/promise.rb

@@ -110,6 +110,51 @@ def rescue(&block)
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
+    # Yield the successful result to the block that returns a promise. If that
+    # promise is also successful the result is the result of the yielded promise.
+    # If either part fails the whole also fails.
+    #
+    # @example
+    #   Promise.execute { 1 }.flat_map { |v| Promise.execute { v + 2 } }.value! #=> 3
+    #
+    # @return [Promise]
+    def flat_map(&block)
+      child = Promise.new(
+        parent: self,
+        executor: ImmediateExecutor.new,
+      )
+
+      on_error { |e| child.on_reject(e) }
+      on_success do |result1|
+        begin
+          inner = block.call(result1)
+          inner.execute
+          inner.on_success { |result2| child.on_fulfill(result2) }
+          inner.on_error { |e| child.on_reject(e) }
+        rescue => e
+          child.on_reject(e)
+        end
+      end
+
+      child
+    end
+
+    # Builds a promise that produces the result of self and others in an Array
+    # and fails if any of them fails.
+    #
+    # @param [Array<Promise>] others
+    #
+    # @return [Promise]
+    def zip(*others)
+      others.reduce(self.then { |x| [x] }) do |p1, p2|
+        p1.flat_map do |results|
+          p2.then do |next_result|
+            results << next_result
+          end
+        end
+      end
+    end
+
     protected
 
     def set_pending

spec/concurrent/promise_spec.rb

@@ -260,6 +260,61 @@ module Concurrent
       end
     end
 
+    describe '#flat_map' do
+
+      it 'returns a promise' do
+        child = empty_root.flat_map { nil }
+        expect(child).to be_a Promise
+        expect(child).not_to be empty_root
+      end
+
+      it 'succeeds if both promises succeed' do
+        child = Promise.new(executor: executor) { 1 }.
+          flat_map { |v| Promise.new(executor: executor) { v + 10 } }.execute.wait
+
+        expect(child.value!).to eq(11)
+      end
+
+      it 'fails if the left promise fails' do
+        child = Promise.new(executor: executor) { fail }.
+          flat_map { |v| Promise.new(executor: executor) { v + 10 } }.execute.wait
+
+        expect(child).to be_rejected
+      end
+
+      it 'fails if the right promise fails' do
+        child = Promise.new(executor: executor) { 1 }.
+          flat_map { |v| Promise.new(executor: executor) { fail } }.execute.wait
+
+        expect(child).to be_rejected
+      end
+
+      it 'fails if the generating block fails' do
+        child = Promise.new(executor: executor) { }.flat_map { fail }.execute.wait
+
+        expect(child).to be_rejected
+      end
+
+    end
+
+    describe '#zip' do
+      let(:promise1) { Promise.new(executor: executor) { 1 } }
+      let(:promise2) { Promise.new(executor: executor) { 2 } }
+      let(:promise3) { Promise.new(executor: executor) { [3] } }
+
+      it 'yields the results as an array' do
+        composite = promise1.zip(promise2, promise3).execute.wait
+
+        expect(composite.value).to eq([1, 2, [3]])
+      end
+
+      it 'fails if one component fails' do
+        composite = promise1.zip(promise2, rejected_subject, promise3).execute.wait
+
+        expect(composite).to be_rejected
+      end
+    end
+
     context 'fulfillment' do
 
       it 'passes the result of each block to all its children' do