Sample code for the blog post about Typed Channels in Akka

FullSample.scala

/**
 * Copyright (C) 2013 Typesafe Inc. <http://www.typesafe.com>
 */

package docs.channels

import akka.actor.{ Actor, ActorSystem }
import akka.channels._
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.Await
import java.lang.{ Double ⇒ JDouble }

class Squarer extends Actor
  with Channels[TNil, (JDouble, Double) :+: TNil] {

  channel[JDouble] {
    case (x, send) ⇒
      send <-!- x * x
  }
}

class StringToDouble(target: ⇒ Actor with Channels[TNil, (JDouble, Double) :+: TNil])
  extends Actor with Channels[TNil, (String, String) :+: TNil] {

  import java.lang.Double.valueOf

  // needed for the Future.map below
  import context.dispatcher

  // needed for the -?-> below  
  implicit val timeout = Timeout(5.seconds)

  lazy val targetRef = createChild(target, "calculator")

  channel[String] {
    case (str, sender) ⇒
      valueOf(str) -?-> targetRef -*-> (_.map(_.toString)) -!-> sender
  }
}

object Demo extends App {
  implicit val timeout = Timeout(1.second)

  val system = ActorSystem("ChannelSample")
  import system.dispatcher

  val handler = ChannelExt(system).actorOf(new StringToDouble(new Squarer), "handler")

  def printLine(): Future[Unit] = Future(readLine) flatMap {
    case null | "exit" => Future.successful(())
    case line => line -?-> handler flatMap { r => println(r); printLine() }
  }

  printLine() onComplete (_ ⇒ system.shutdown())
}

Main.scala

object Demo extends App {
  implicit val timeout = Timeout(1.second)

  val system = ActorSystem("ChannelSample")
  import system.dispatcher

  val handler =
    ChannelExt(system).actorOf(new StringToDouble(new Squarer), "handler")

  def printLine(): Future[Unit] = Future(readLine) flatMap {
    case null | "exit" => Future.successful(())
    case line => line -?-> handler flatMap { r => println(r); printLine() }
  }

  printLine() onComplete (_ ⇒ system.shutdown())
}

Squarer.scala

class Squarer extends Actor
  with Channels[TNil, (JDouble, Double) :+: TNil] {

  channel[JDouble] {
    case (x, sender) ⇒
      sender <-!- x * x
  }
}

StringToDouble.scala

class StringToDouble(
    target: ⇒ Actor with Channels[TNil, (JDouble, Double) :+: TNil]
  )
  extends Actor with Channels[TNil, (String, String) :+: TNil] {

  import java.lang.Double.valueOf

  // needed for the Future.map below
  import context.dispatcher

  // needed for the -?-> below  
  implicit val timeout = Timeout(5.seconds)

  lazy val targetRef = createChild(target, "calculator")

  channel[String] {
    case (str, sender) ⇒
      valueOf(str) -?-> targetRef -*-> (_.map(_.toString)) -!-> sender
  }
}

You're most welcome!