akka.actor.ask response type

AkkaUtil.scala

import akka.actor.{ ActorSystem, Actor, ActorRef, Props }
import akka.dispatch.Future
import akka.pattern.ask
import akka.util.duration._
import akka.util.Timeout
import AkkaUtil.{ ResponseType, askT }

object AkkaUtil {
  trait ResponseType[T, R]

  def askT[T, R](actor: ActorRef, msg: T)(implicit timeout: Timeout, rt: ResponseType[T, R], m: Manifest[R]): Future[R] =
    ask(actor, msg).mapTo(m)
}

object SomeActor {
  sealed trait Message
  case class Message1(param1: Any) extends Message
  case object Message2 extends Message

  implicit object Message1ResponseType extends ResponseType[Message1, Option[String]]
  implicit object Message2ResponseType extends ResponseType[Message2.type, Seq[Int]]
}

class SomeActor extends Actor {
  import SomeActor._

  protected def receive = {
    case Message1(param1) =>
      sender ! Some(param1.toString)

    case Message2 =>
      sender ! Seq(1, 2, 3)
  }
}

object Main extends App {
  val system = ActorSystem()
  val someActor = system.actorOf(Props[SomeActor])

  implicit val timeout = Timeout(5 seconds)

  val response1: Future[Option[String]] = ask(someActor, SomeActor.Message1(1)).mapTo[Option[String]]
  val response1T: Future[Option[String]] = askT(someActor, SomeActor.Message1(1))

  val response2: Future[Seq[Int]] = ask(someActor, SomeActor.Message2).mapTo[Seq[Int]]
  val response2T: Future[Seq[Int]] = askT(someActor, SomeActor.Message2)

  response1 foreach { println _ }
  response1T foreach { println _ }
  response2 foreach { println _ }
  response2T foreach { println _ }
}