Patterns around storing Actor<ActorableProtocol>

[ktoso]

Double check and document patterns around storing Actor<SomeProtocol> this it may be running into trouble with protocols.

Sanity check and document what do do there.

Perhaps we can offer something similar as ReceivesSystemMessages for Actors, not sure if it makes sense - just a thought.

[ktoso]

If you have some specific problems in mind here @budde let me know 👍

[budde]

It'd be great to support a reference to Actorable actors that conform to some protocol rather than the concrete Actor<SomeActorable> in order to express some generic protocol-based patterns and reduce boilerplate code.

For example, I could image building an actor system where we want to route messages from some external source to actors of heterogenous type in our system:

enum MessageType: Codable {
  case foo
  case bar
}

protocol MessageTarget: Actorable {
  func handleMessage(_ message: MessageType)
}

class MessageRouter: Actorable {
  // Map of target identifier to Actor
  var targets: [String: Actor<MessageTarget>]

  // Invoked by actors to register as targets
  func registerTarget(_ identifier: String, actor: Actor<MessageTarget>) {
    targets[identifier] = actor
  }

  // Invoked by some other component receiving messages from an external
  func dispatchMessage(_ identifier: String, message: MessageType) {
    if let target = targets[identifier] {
      target.handleMessage(message)
    } else {
      // do some error handling
    }
  }
}

And some contrived MessageTarget implementations:

class FooTarget: Actorable, MessageTarget {
  let router: Actor<MessageRouter>
  let identifier: String

  init(
    router: Actor<MessageRouter>,
    identifier: String = UUID().uuidString
  ) {
    self.router = router
    self.identifier = identifier
  }

  func preStart(context: Myself.Context) {
    router.registerTarget(self.identifier, actor: context.myself)
  }

  func handleMessage(_ message: MessageType) {
    switch message {
    case foo:
      // do some foo stuff
    default:
      // do some error handling
    }
  }
}

class BarTarget: Actorable, MessageTarget {
  let router: Actor<MessageRouter>
  let identifier: String

  init(
    router: Actor<MessageRouter>,
    identifier: String = UUID().uuidString
  ) {
    self.router = router
    self.identifier = identifier
  }

  func preStart(context: Myself.Context) {
    router.registerTarget(self.identifier, actor: context.myself)
  }

  func handleMessage(_ message: MessageType) {
    switch message {
    case bar:
      // do some bar stuff
    default:
      // do some error handling
    }
  }
}

Right now, we would get a compiler error in such a scenario stating that Actor<>s must be of some concrete type rather than a protocol.

[ktoso]

Hey, sorry for not replying in thread here! We did catch up in chats/calls on this though...

I'll give it a look soon though, as wrapping up the hardening work now.
Thank's a lot for the feedback and example snippet!

[ktoso]

Will do in 0.5.2