scala - samsung - ¿Cómo restringir los mensajes del actor a tipos específicos?

como bloquear mensajes de texto en samsung

Question

En Akka , ¿hay alguna forma de restringir los mensajes a los actores para que sean de un tipo estático específico que no sea el uso de las API "Typed Actor" que utilizan un modelo de programación de estilo RPC?

¿Puedo usar el estilo de pase de mensajes con Akka sin descartar la seguridad de tipo estático en los límites del actor?

Por ejemplo, me gustaría usar un código como este:

sealed abstract class FooMessage
case object Foo extends FooMessage
case object Bar extends FooMessage
class FooActor extends Actor[FooMessage] {
def receive = {
case Foo => () // OK
// Would raise a compiler error:
// case s: String => error("Can''t happen, String is not a subtype of FooMessage")
}
}
val fooActor = actorOf[FooActor]
fooActor ! Foo // OK
// Won''t compile:
fooActor ! "Hello"

Quizás uno debería extender algún rasgo base o tener un constructo como Either para permitir mensajes a nivel del sistema ( Exit , etc.).

Answer 1

En Scala stdlib había una excusa para hacer que los actores básicos se tipearan (lo que no se aplica a Akka, porque no admite las recepciones anidadas, como recuerdo). Lift, a su vez, admite actores tipeados listos para usar.

Sin embargo, al usar canales, aún es posible crear actores fuertemente tipados con stdlib:

object TypedActor {
def apply[A](fun: PartialFunction[A, Any]): OutputChannel[A] = {
val sink = new SyncVar[Channel[A]]
actor {
val in = new Channel[A](self)
sink set in
loop {
in react { case any => reply(fun(any)) }
}
}
sink.get
}
}
sealed abstract class FooMessage
case object Foo extends FooMessage
case object Bar extends FooMessage
object Test {
val fooActor = TypedActor[FooMessage]{
case Foo => println("OK")
}
fooActor ! Foo
fooActor ! "Hello!" // doesn''t compile -> Type mismatch; found: String("Hello!"); required: FooMessage;
}

Answer 2

En realidad, restringir a un Actor para que tenga solo un tipo de entrada no es muy útil. Lo que es más útil para mi mente es enumerar posibles entradas de una manera estrictamente tipada.

Hay un enfoque para entradas estrictamente tipadas de actores ( SynapseGrid ):

case class Contact[T](...)
case class Signal[T](contact:Contact[T], data:T)

En su caso, la interfaz consiste en un solo contacto de entrada:

val FooInput = contact[FooMessage]("FooInput")

Dentro del marco SynapseGrid, el manejo de las señales se define con Builder:

class FooActorBuilder extends SystemBuilder {
inputs(FooInput, OtherInput)
FooInput.foreach(fooMessage => () //OK
)
OtherInput.foreach(...)
}

Obviamente, uno no puede construir señales con tipos incompatibles. Por lo tanto, tenemos tiempo de compilación de comprobación. En SynapseGrid hay una DSL para trabajar con señales y contactos. Por ejemplo, para enviar Foo o Bar desde afuera:

val SomeOtherContact = contact[Boolean]("SomeOtherContact")
SomeOtherContact.map(flag => if(flag) Foo else Bar) >> FooInput

Por supuesto, uno puede simplemente enviar el mensaje:

val inputMessage = Signal(FooInput, Foo)
actor ! inputMessage

Answer 3

Luego tendría que codificar el tipo de mensaje en la referencia del actor, lo que disminuiría drásticamente el valor de algo así como ActorRegistry.

Además, con mecánicas potentes como "become" (que es fundamental para el modelo de actor), escribir los mensajes es menos valioso.

Como Akka no pierde memoria cuando un mensaje no coincide con el comportamiento actual, no existe el mismo riesgo de enviar mensajes "incorrectos" al actor "equivocado".

Además, los actores son dinámicos por naturaleza, así que si quieres que sean estáticos, utiliza TypedActor (que no es RPC, es solo como RPC como actores comunes, métodos nulos son! Llamadas, tipo de retorno futuro es !!! y otros tipos de devolución estan basados ​​en !!)

La práctica común es declarar qué mensajes puede recibir un Actor en el objeto complementario del Actor, lo que hace que sea mucho más fácil saber qué puede recibir.

¿Eso ayuda?

Answer 4

Parece que el soporte del Akka''s Typed Channel fue haber abordado esto, pero (de acuerdo con el comentario ya ha sido eliminado de Akka en la versión 2.3 ).

En la documentación de Akka 2.2.3, hay una buena sección de "antecedentes de diseño" que analiza las dificultades en el envío de mensajes y respuestas de mensajes escritos.

También hay una buena charla sobre NEScala de Roland Kuhn, Canales tipificados de Akka: Implementación de cálculos de tipo como macros ( [YouTube] / [Slides] ), que analiza la implementación de canales escritos.