Akka/Scala: onSuccess for multiple asks to different actor - scala

Question

I'm trying to make an async call to different sub-actors, such as:
A ---> B ---> C
\---> D
Actor A sends a request message to Actor B and B send two task messages to C and D, when C and D send the results back, B merge the results up and send it back to the A.
I was trying to use ask pattern and onSuccess to solve this:
class B(fakeInterface: String, subInterface: Array[ActorRef]) extends Actor {
val subCount = subInterface.length
var finishCount = 0
def receive = {
case reqMsg(msg) =>
if (subInterface.length == 0){
sender ! DoneMessage(msg)
} else {
implicit val timeout = Timeout(5 minutes)
val composedFutures = subInterface map { x =>
(x ? DoItMessage(msg)).mapTo[DoneMessage]
}
val allResult = Future.sequence(composedFutures)
allResult.onSuccess {
case _ => sender ! DoneMessage(msg)
}
}
}
}
But the code above does not compile at all, I got three error:
[error] inferred type arguments [dummy.DoneMessage,Array] do not conform to method sequence's type parameter bounds [A,M[_] <: TraversableOnce[_]]
[error] val allResult = Future.sequence(composedFutures)
[error] ^
[error] type mismatch;
[error] found : Array[scala.concurrent.Future[dummy.DoneMessage]]
[error] required: M[scala.concurrent.Future[A]]
[error] val allResult = Future.sequence(composedFutures)
[error] ^
[error] Cannot construct a collection of type M[A] with elements of type A based on a collection of type M[scala.concurrent.Future[A]].
[error] val allResult = Future.sequence(composedFutures)
[error] ^
[error] three errors found
How can I fix this? Or is there a more proper way to solve this scenario?

Answer 1

Array is not a TraversableOnce. There is an implicit conversion from Array to WrappedArray which is a TraversableOnce, but by the time the type parameter has been inferred to Array it is too late for the implicit conversion. If you replace Array with one of the classes from the collections library, e.g. List you can get past these compiler errors.
The ask pattern is inefficient because it has to create a fake actor for every request, which creates considerable overhead. It is useful for allowing non-actor code to communicate with actors, but actors themselves should message each other directly. Actor B will have to be stateful so it can keep track of messages from C and D as they come back, but it would make for a better solution.

Answer 2

scala.Array does not inherit from scala.collection.TraversableOnce so it cannot be used with Future.sequence. Try using a List or Seq instead.
http://www.scala-lang.org/api/current/index.html#scala.Array