Dr. Roland Kuhn@rolandkuhn
Typed Channelsand
Macros
söndag 10 februari 13
someActor ! CommandOne
The Problem
söndag 10 februari 13
trait Commandcase class CommandOne(param: String) extends Command
someActor ! CommandOne
The Problem
söndag 10 februari 13
because the other does not compile
someActor <-!- CommandOne(”msg”)
The Vision
söndag 10 februari 13
But How?
• ActorRef must know about message types– Actor type must be parameterized
• Message type is verified against that
söndag 10 februari 13
val f: Future[Response] =
someActor <-?- CommandOne(”hello”)
because the compiler knows
And the replies?
söndag 10 februari 13
And How This?
• ActorRef must know reply types– Actor must be parameterized with them
• Reply types are extracted at call site
söndag 10 februari 13
No Type Pollution
• Generic Filter/Transform Actors– accept management commands– pass on generic other type
• Using just one type is not enough!
• Need to use type unions and allow multiple possible reply types for one input
söndag 10 februari 13
msg -?-> firstActor -?-> secondActor -!-> client
msg -?-> someService -*-> (_ map httpOk) -!-> client
Process wiring from the outside
Actors Do Compose
söndag 10 februari 13
The Result:
söndag 10 februari 13
Type-Safe Composability
of
Actor Systems
söndag 10 februari 13
Relation to π-calculus
• Actors are composite processes
• Actor types are structural, not nominal
• wiring A⌒B can be done situationally
http://doc.akka.io/ see Typed Channels
söndag 10 februari 13
That was theEloi world
Now we’re going to visit the Morlocks
söndag 10 februari 13
The Implementation
• Tagged type union with:+:[(In, Out), ChannelList] <: ChannelList
• Value class ChannelRef[…](val a: ActorRef)
• Actor mixin Channels[…]
• WrappedMessage[…, LUB](val m: LUB)
• ops desugar to tell/ask after type check
söndag 10 februari 13
class OpinionatedEcho extends Actor with Channels[TNil, (String, String) :+: TNil] {
channel[String] { (str, sender) ⇒ sender <-!- str } // or channel[String] { case (”hello”, sender) ⇒ sender <-!- ”world” case (x, sender) ⇒ sender <-!- s”dunno: $x” }
}
“sender” will accept only String messages
How to Declare it?
söndag 10 februari 13
First Problem: Lambdas
• Type-checker transforms lambda before the macro call– pattern matches or PartialFunction literals
generate checks depending on static type info
• Behavior is not an argument to “channels”
• macro only emits object with right “apply”
söndag 10 februari 13
private class Behaviorist[-R, Ch: ru.TypeTag]( wrapped: Boolean) extends (R ⇒ Unit) { // ... def apply(recv: R): Unit = { val tt = ru.typeTag[Ch] behavior ++= ( for (t ← inputChannels(ru)(tt.tpe)) yield tt.mirror.runtimeClass(t.widen) -> ff(recv)) } }
calling channels[_] registers the behavior
First Problem: Lambdas
söndag 10 februari 13
def impl[LUB, ReplyChannels <: ChannelList, MsgTChan <: ChannelList, MsgT: c.WeakTypeTag, MyCh <: ChannelList: c.WeakTypeTag, ParentCh <: ChannelList: c.WeakTypeTag]( c: Context { type PrefixType = Channels[ParentCh, MyCh] }): c.Expr[(Nothing ⇒ Unit)] = { // some type calculations happen here val prepTree = reify(...) reify { prepTree.splice c.prefix.splice.behaviorist[ (MsgT, ChannelRef[ReplyChannels]) ⇒ Unit, MsgT]( bool(c, false).splice)(universe.typeTag[MsgT]) } }
The Gory Details
söndag 10 februari 13
trait Channels[P <: ChannelList, C <: ChannelList] { this: Actor ⇒
def channel[T]: (Nothing ⇒ Unit) = macro macros.Channel.impl[Any, ChannelList, ChannelList, T, C, P]
def behaviorist[R, Ch: ru.TypeTag](wrapped: Boolean) : (R ⇒ Unit) = new Behaviorist[R, Ch](wrapped)
// ... }
The Gory Details
söndag 10 februari 13
final def missingChannels(u: Universe)( channels: u.Type, required: List[u.Type]): List[u.Type] = { import u._ // making the top-level method recursive blows up the compiler def rec(ch: Type, req: List[Type]): List[Type] = { ch match { case TypeRef(_, _, TypeRef(_, _, in :: _) :: tail :: Nil) ⇒ rec(tail, req filterNot (_ <:< in)) case last ⇒ req filterNot (_ <:< last) } } rec(channels, required) }
Sample Type Calculation
söndag 10 februari 13
def impl[..., ReplyChannels <: ChannelList, ...] (c: Context): c.Expr[(Nothing ⇒ Unit)] = { // calculate “channels: u.Type” and then: implicit val ttReplyChannels = c.TypeTag[ReplyChannels](channels) reify { ...[(..., ...[ReplyChannels]) ⇒ ..., ...]... } }
“reify” picks up TypeTags and uses their .tpe
How to Return a Type
söndag 10 februari 13
final def x(u: Universe)(list: u.Type, msg: u.Type) : List[u.Type] = { val imp = u.mkImporter(ru) val tpeReplyChannels = imp.importType(ru.typeOf[ReplyChannels[_]]) val tpeTNil = imp.importType(ru.typeOf[TNil]) // ... }
otherwise there will be weird exceptions
Sharing Code with Runtime
söndag 10 februari 13
def mkToolbox(compileOptions: String = "") : ToolBox[_ <: scala.reflect.api.Universe] = { val m = scala.reflect.runtime.currentMirror m.mkToolBox(options = compileOptions) }
def eval(code: String, compileOptions: String = "-cp akka-actor/target/classes:akka-channels/target/classes") : Any = { val tb = mkToolbox(compileOptions) tb.eval(tb.parse(code)) }
How to test it?
söndag 10 februari 13
intercept[ToolBoxError] { eval(""" import akka.channels._ import ChannelSpec._ implicit val c = new ChannelRef[TNil](null) new ChannelRef[(A, C) :+: TNil](null) <-!- B """) }.message must include( "target ChannelRef does not support messages of " + "types akka.channels.ChannelSpec.B.type")
How to test it?
söndag 10 februari 13
get it and learn morehttp://akka.io
http://typesafe.com
http://letitcrash.com
söndag 10 februari 13
E0Fsöndag 10 februari 13
Top Related