gistfile1.txt

package com.typesafe.training.hakkyhour

import akka.actor.{ Actor, ActorRef, ActorSystem, Props }
import akka.pattern.{ ask, pipe }
import akka.util.Timeout

import scala.concurrent.{ Future, Await }
import scala.concurrent.duration._

case class DoTask(num: Int)
case class TheWorkers(l: List[ActorRef])

class Worker extends Actor {
  override def receive = {
    case DoTask(num) =>
      sender ! "result" + num
  }
}

class ActorWithTasks extends Actor {
  implicit val timeout: Timeout = 2.seconds
  implicit val ec = context.dispatcher
  
  override def receive = {
    case TheWorkers(workers) =>
/* sequential:
      val whenAllDone = for {
        res1 <- w1 ? DoTask(1)
        res2 <- w2 ? DoTask(2)
        res3 <- w3 ? DoTask(3)
      } yield List(res1, res2, res3)
*/    
/* the same:
      val whenAllDone =
        (w1 ? DoTask(1)).flatMap(res1 =>
          (w2 ? DoTask(2)).flatMap(res2 =>
            (w3 ? DoTask(3)).map(res3 => List(res1, res2, res3))))
*/

/* in parallel:
      val req1 = w1 ? DoTask(1)
      val req2 = w2 ? DoTask(2)
      val req3 = w3 ? DoTask(3)
*/
      
      val tasks = 1 to 3 map DoTask
      val requests = (tasks zip workers).map {
        case (task, worker) => worker ? task
      }
      val whenAllDone = Future.sequence(requests)
      
      (whenAllDone map { seq =>
        seq.mkString(",")
      }).pipeTo(sender)
  }
}

object MultipleActors extends App {
  val sys = ActorSystem()
  implicit val timeout: Timeout = 2.seconds
  
  val workers = (1 to 3).toList.map(num => sys.actorOf(Props[Worker]))
  val hasTasks = sys.actorOf(Props[ActorWithTasks])
  
  val finalRes = (hasTasks ? TheWorkers(workers)).mapTo[String]
  println("The winning answer is:")
  println(Await.result(finalRes, 2.seconds))
}