Edge::Future: auto splat array values when used as arguments for blocks

Author: pitr-ch

examples/edge_futures.in.rb

@@ -22,12 +22,15 @@
 head    = Concurrent.future { 1 } #
 branch1 = head.then(&:succ) #
 branch2 = head.then(&:succ).then(&:succ) #
-branch1.zip(branch2).value
+branch1.zip(branch2).value!
 (branch1 & branch2).then { |a, b| a + b }.value!
 (branch1 & branch2).then(&:+).value!
 Concurrent.zip(branch1, branch2, branch1).then { |*values| values.reduce &:+ }.value!
 # pick only first completed
-(branch1 | branch2).value
+(branch1 | branch2).value!
+
+# auto splat arrays for blocks
+Concurrent.future { [1, 2] }.then(&:+).value!
 
 
 ### Error handling
@@ -209,7 +212,7 @@ def schedule_job
 
 DB_POOL = Concurrent::Actor::Utils::Pool.spawn!('DB-pool', pool_size) do |index|
   # DB connection constructor
-  Concurrent::Actor::Utils::AdHoc.spawn(name: "worker-#{index}", args: [data]) do
+  Concurrent::Actor::Utils::AdHoc.spawn(name: "worker-#{index}", args: [data]) do |data|
     lambda do |message|
       # pretending that this queries a DB
       data[message]

examples/edge_futures.out.rb

@@ -1,7 +1,7 @@
 ### Simple asynchronous task
 
 future = Concurrent.future { sleep 0.1; 1 + 1 } # evaluation starts immediately
-    # => <#Concurrent::Edge::Future:0x7fa1b59bbbb8 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc038ca588 pending blocks:[]>
 future.completed?                                  # => false
 # block until evaluated
 future.value                                       # => 2
@@ -11,7 +11,7 @@
 ### Failing asynchronous task
 
 future = Concurrent.future { raise 'Boom' }
-    # => <#Concurrent::Edge::Future:0x7fa1b59b2fe0 failed blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc038c05b0 pending blocks:[]>
 future.value                                       # => nil
 future.value! rescue $!                            # => #<RuntimeError: Boom>
 future.reason                                      # => #<RuntimeError: Boom>
@@ -24,13 +24,16 @@
 head    = Concurrent.future { 1 } 
 branch1 = head.then(&:succ) 
 branch2 = head.then(&:succ).then(&:succ) 
-branch1.zip(branch2).value                         # => [2, 3]
+branch1.zip(branch2).value!                        # => [2, 3]
 (branch1 & branch2).then { |a, b| a + b }.value!   # => 5
 (branch1 & branch2).then(&:+).value!               # => 5
 Concurrent.zip(branch1, branch2, branch1).then { |*values| values.reduce &:+ }.value!
     # => 7
 # pick only first completed
-(branch1 | branch2).value                          # => 2
+(branch1 | branch2).value!                         # => 2
+
+# auto splat arrays for blocks
+Concurrent.future { [1, 2] }.then(&:+).value!      # => 3
 
 
 ### Error handling
@@ -47,21 +50,21 @@
 
 # will not evaluate until asked by #value or other method requiring completion
 future = Concurrent.delay { 'lazy' }
-    # => <#Concurrent::Edge::Future:0x7fa1b5948f00 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc022afaa0 pending blocks:[]>
 sleep 0.1 
 future.completed?                                  # => false
 future.value                                       # => "lazy"
 
 # propagates trough chain allowing whole or partial lazy chains
 
 head    = Concurrent.delay { 1 }
-    # => <#Concurrent::Edge::Future:0x7fa1b59401c0 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc022a5640 pending blocks:[]>
 branch1 = head.then(&:succ)
-    # => <#Concurrent::Edge::Future:0x7fa1b5933290 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc0229c478 pending blocks:[]>
 branch2 = head.delay.then(&:succ)
-    # => <#Concurrent::Edge::Future:0x7fa1b5930c98 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc0228f318 pending blocks:[]>
 join    = branch1 & branch2
-    # => <#Concurrent::Edge::ArrayFuture:0x7fa1b592b7c0 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc0228de78 pending blocks:[]>
 
 sleep 0.1 # nothing will complete                  # => 0
 [head, branch1, branch2, join].map(&:completed?)   # => [false, false, false, false]
@@ -89,14 +92,14 @@
 ### Schedule
 
 scheduled = Concurrent.schedule(0.1) { 1 }
-    # => <#Concurrent::Edge::Future:0x7fa1b49df190 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc0385b368 pending blocks:[]>
 
 scheduled.completed?                               # => false
 scheduled.value # available after 0.1sec           # => 1
 
 # and in chain
 scheduled = Concurrent.delay { 1 }.schedule(0.1).then(&:succ)
-    # => <#Concurrent::Edge::Future:0x7fa1b49d4ec0 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc03843948 pending blocks:[]>
 # will not be scheduled until value is requested
 sleep 0.1 
 scheduled.value # returns after another 0.1sec     # => 2
@@ -105,35 +108,35 @@
 ### Completable Future and Event
 
 future = Concurrent.future
-    # => <#Concurrent::Edge::CompletableFuture:0x7fa1b49bce10 pending blocks:[]>
+    # => <#Concurrent::Edge::CompletableFuture:0x7fcc0304fdb8 pending blocks:[]>
 event  = Concurrent.event
-    # => <#Concurrent::Edge::CompletableEvent:0x7fa1b49bc118 pending blocks:[]>
+    # => <#Concurrent::Edge::CompletableEvent:0x7fcc0304e210 pending blocks:[]>
 
 # will be blocked until completed
 t1     = Thread.new { future.value } 
 t2     = Thread.new { event.wait } 
 
 future.success 1
-    # => <#Concurrent::Edge::CompletableFuture:0x7fa1b49bce10 success blocks:[]>
+    # => <#Concurrent::Edge::CompletableFuture:0x7fcc0304fdb8 success blocks:[]>
 future.success 1 rescue $!
     # => #<Concurrent::MultipleAssignmentError: multiple assignment>
 future.try_success 2                               # => false
 event.complete
-    # => <#Concurrent::Edge::CompletableEvent:0x7fa1b49bc118 completed blocks:[]>
+    # => <#Concurrent::Edge::CompletableEvent:0x7fcc0304e210 completed blocks:[]>
 
 [t1, t2].each &:join 
 
 
 ### Callbacks
 
-queue  = Queue.new                                 # => #<Thread::Queue:0x007fa1b49acec0>
+queue  = Queue.new                                 # => #<Thread::Queue:0x007fcc03101720>
 future = Concurrent.delay { 1 + 1 }
-    # => <#Concurrent::Edge::Future:0x7fa1b49ac150 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc030fbaf0 pending blocks:[]>
 
 future.on_success { queue << 1 } # evaluated asynchronously
-    # => <#Concurrent::Edge::Future:0x7fa1b49ac150 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc030fbaf0 pending blocks:[]>
 future.on_success! { queue << 2 } # evaluated on completing thread
-    # => <#Concurrent::Edge::Future:0x7fa1b49ac150 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc030fbaf0 pending blocks:[]>
 
 queue.empty?                                       # => true
 future.value                                       # => 2
@@ -144,15 +147,15 @@
 ### Thread-pools
 
 Concurrent.future(:fast) { 2 }.then(:io) { File.read __FILE__ }.wait
-    # => <#Concurrent::Edge::Future:0x7fa1b498dd18 success blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc030e8bd0 success blocks:[]>
 
 
 ### Interoperability with actors
 
 actor = Concurrent::Actor::Utils::AdHoc.spawn :square do
   -> v { v ** 2 }
 end
-    # => #<Concurrent::Actor::Reference /square (Concurrent::Actor::Utils::AdHoc)>
+    # => #<Concurrent::Actor::Reference:0x7fcc0223f020 /square (Concurrent::Actor::Utils::AdHoc)>
 
 Concurrent.
     future { 2 }.
@@ -165,32 +168,32 @@
 
 ### Interoperability with channels
 
-ch1 = Concurrent::Edge::Channel.new                # => #<Concurrent::Edge::Channel:0x007fa1b41c5e28>
-ch2 = Concurrent::Edge::Channel.new                # => #<Concurrent::Edge::Channel:0x007fa1b41c5338>
+ch1 = Concurrent::Edge::Channel.new                # => #<Concurrent::Edge::Channel:0x007fcc021ec6b8>
+ch2 = Concurrent::Edge::Channel.new                # => #<Concurrent::Edge::Channel:0x007fcc021e7b18>
 
 result = Concurrent.select(ch1, ch2)
-    # => <#Concurrent::Edge::CompletableFuture:0x7fa1b41bf4d8 pending blocks:[]>
+    # => <#Concurrent::Edge::CompletableFuture:0x7fcc021e6060 pending blocks:[]>
 ch1.push 1                                         # => nil
 result.value!
-    # => [1, #<Concurrent::Edge::Channel:0x007fa1b41c5e28>]
+    # => [1, #<Concurrent::Edge::Channel:0x007fcc021ec6b8>]
 
 Concurrent.
     future { 1+1 }.
     then_push(ch1)
-    # => <#Concurrent::Edge::Future:0x7fa1b41b6450 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc021dc3d0 pending blocks:[]>
 result = Concurrent.
     future { '%02d' }.
     then_select(ch1, ch2).
     then { |format, (value, channel)| format format, value }
-    # => <#Concurrent::Edge::Future:0x7fa1b41a7f40 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc021cd9e8 pending blocks:[]>
 result.value!                                      # => "02"
 
 
 ### Common use-cases Examples
 
 # simple background processing
 Concurrent.future { do_stuff }
-    # => <#Concurrent::Edge::Future:0x7fa1b4196d08 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc021b7530 pending blocks:[]>
 
 # parallel background processing
 jobs = 10.times.map { |i| Concurrent.future { i } } 
@@ -207,7 +210,7 @@ def schedule_job
 end                                                # => :schedule_job
 
 schedule_job
-    # => <#Concurrent::Edge::Future:0x7fa1b4147960 pending blocks:[]>
+    # => <#Concurrent::Edge::Future:0x7fcc0218faf8 pending blocks:[]>
 @end = true                                        # => true
 
 
@@ -220,7 +223,7 @@ def schedule_job
     data[message]
   end
 end
-    # => #<Concurrent::Actor::Reference /db (Concurrent::Actor::Utils::AdHoc)>
+    # => #<Concurrent::Actor::Reference:0x7fcc0214f458 /db (Concurrent::Actor::Utils::AdHoc)>
 
 concurrent_jobs = 11.times.map do |v|
   Concurrent.
@@ -243,14 +246,14 @@ def schedule_job
 
 DB_POOL = Concurrent::Actor::Utils::Pool.spawn!('DB-pool', pool_size) do |index|
   # DB connection constructor
-  Concurrent::Actor::Utils::AdHoc.spawn(name: "worker-#{index}", args: [data]) do
+  Concurrent::Actor::Utils::AdHoc.spawn(name: "worker-#{index}", args: [data]) do |data|
     lambda do |message|
       # pretending that this queries a DB
       data[message]
     end
   end
 end
-    # => #<Concurrent::Actor::Reference /DB-pool (Concurrent::Actor::Utils::Pool)>
+    # => #<Concurrent::Actor::Reference:0x7fcc02930398 /DB-pool (Concurrent::Actor::Utils::Pool)>
 
 concurrent_jobs = 11.times.map do |v|
   Concurrent.