A behaviour module for implementing general purpose actors.

A Comms.Actor is designed to allow easy implementation of the actor model.

Example

defmodule Ping do
  use Comms.Actor

  @impl Comms.Actor
  def handle({:ping, pid}, state) do
    {[{pid, :pong}], state}
  end
end

{:ok, p} = Comms.Actor.start_link(Ping, nil)

send(p, {:ping, self()})

flush()
# => :pong

Actor Model

An actor is a computational entity that, in response to a message it receives, can concurrently:

1. send a finite number of messages to other actors;
2. create a finite number of new actors;
3. designate the behavior to be used for the next message it receives.

There is no assumed sequence to the above actions and they could be carried out in parallel.

The Comms.Actor behavior is a replacement for GenServer that more closely follows these principles.

• There is only one callback to deal with incomming messages, handle/2. Comms.Actor works with GenServer.call/2 etc but these are just another type of message
• The return value of the handle/2 callback is always the same shape. A list of outbound messages and a new state. This allows an Comms.Agent to send any number of replies rather than 1 or 0 that is the case for GenServers.

Gen messages

Calls and cast from the GenServer module etc are just wrappers around the erlang :gen module. A proccess implementing Comms.Actor can respond to these like normal messages.

defmodule PairUp do
  use Comms.Actor

  def start_link do
    Comms.Actor.start_link(__MODULE__, :none)
  end

  @impl Comms.Actor
  def handle({:"$gen_call", from, {:pair, pid}}, :none) do
    {[], {:waiting, from, pid}}
  end
  def handle({:"$gen_call", from2, {:pair, pid2}}, {:waiting, from1, pid1}) do
    messages = [
      {from2, {:other, pid1}},
      {from1, {:other, pid2}},
    ]
    {messages, :none}
  end
end