Just fooling around.
// Define an Epoch task that does some work
task Worker :
// This specifies a "message signature" which can be
// used by and instance of this task to receive data
// and commands from other code.
Work : integer a, integer b
// Do some computation
integer result = a + b
// Reply to the sender of the message with another
// message, carrying the fact that we're done, and
// the result of our computation.
sender ~> Completed(result)
// Define another task, which is responsible
// for generating work. It also must contain
// the message response signature for taking
// the results back from the worker.
task Requester :
// This message tells the requester to make up some work
Request : Worker ref worker
// Generate some data
integer a = random()
integer b = random()
// Work on it!
// This syntax directs the Work message to reply to this
// task when it is done. The responses will be delivered
// via Completed messages.
worker ~> Work(a, b) ~> self
// This message is received when the worker
// is done doing its thing. It prints stuff
// so work has some visible effect.
Completed : integer result
print(cast(string, result) ; " came from task!")
// Now we write a standard entrypoint procedure.
// We're going to create a worker pool, and then
// fire work at each worker a whole bunch.
// First our pool of workers...
// This syntax allocates an object (task) which is garbage collected as necessary
new Worker w1
new Worker w2
new Worker w3
new Worker w4
// Now a wrapper to handle requests...
new Requester r
// And now we get busy!
integer workcount = 0
while((workcount++) < 1000)
r ~> Request(w1) // Asynchronously pass Request message with no reply expected
r ~> Request(w2)
r ~> Request(w3)
r ~> Request(w4)
Voila - 4 core random number summation engine!