How is "become" implemented in languages that support the actor model?

Question

The actor model is nicely described by Gul Agha on his technical report, "Actors: a model of concurrent computation in distributed systems".

On page 49 he explains the "become" command:

become <expression>

After calling "become X", an actor will forward all his messages to another actor's mailbox (X).

I'm not sure, however, how this is implemented (it it's implemented at all) in languages like Erlang and Scala. Is it somethign I have to code manually? What about efficiency? Agha shows an implementation of a stack using message-passing. Every time a pop or push is performed, one more forwarding link is added to some actor... After hundreds of thousands of operations, I'd expect such an implementation to spend too much time forwarding messages and not doing actual work, unless some nice optimizations were performed under the hood.

So my question is: how is forwarding (or "become") implemented in typical actor languages like Erlang, Scala (and libraries for other languages)?

Answer 1

It isn't directly implemented in Erlang, but you could write a trivial become function that receives a message, forwards it to another process and then calls itself:

become(Pid) ->
    receive
        Msg -> Pid ! Msg
    end,
    become(Pid).

(An industrial-strength version of this might need to deal with signals and other odds and ends, but this is the essence of it.)

Calling become(Pid) would effectively turn the calling process into process Pid from the outside world's perspective.

This doesn't address the problems you highlight, with repeated calls to become causing growth of forwarding chains. However, this doesn't generally occur in Erlang, and I'm not sure how Erlang's processes map onto the Actor model.