IMO this is not really about parallel computation, but about syntax and scope, and it can be solved without changing ruby.

One solution that seems fairly idiomatic to me is:

def get_response_from_service_a; "a response"; end
def get_response_from_service_b; "b response"; end

class Parallels
def initialize
@tasks = []
end
def task &task
@tasks << Thread.new(&task)
end
def values
@tasks.map {|task| task.value}
end
end

def parallels &task_block
par = Parallels.new
par.instance_eval &task_block
par.values
end

a, b = parallels do
task { get_response_from_service_a }
task { get_response_from_service_b }
end

p a, b

You're right Joel. Maybe the syntax I'm requesting to be included in standard Ruby should be something like:

concurrently do
task {...}
...
end

But, although the implementation is simple, having a standard idiom for that common requirement would be great. That means I wouldn't have to redefine this idiom not to rely on external gem while doing some scripting... Other than that, making it a language feature could allow some low level improvements in performance, but it is just a guess since I don't know how this could be achieved yet.

Furthermore, depending on the specs, maybe it wouldn't be necessary to do something like "a, b = concurrently do...". Being a standard idiom, someone looking at a code like this would know for sure what is happening since it is a language feature instead of an external dependency...

Also, my initial example was too simple, but I imagine possibly several variables inside each task that should be available at the end of the parallels/concurrently block.

Received.

You want just Kernel#concurrently and Kernel#task?
And, Kernel#concurrently returns an array that contains the result values returned by inside Kernel#tasks. Right?
The array may be shuffled, or in the same order as task definitions?

ary = concurrently do
task { 1 }
task { 2 }
task { 3 }
end
p ary #=> [1, 2, 3]

--
Yusuke Endoh [email protected]

If we're going to care about the results of the tasks, which I think it is a good idea, although it was really yours and not mine, it only makes sense to me for the array to have the results in the same order as the tasks were defined, right?

Okay, thanks for considering it :)