To answer your question, no reason at all, it should probably be a symbol, will change that.

The server code that calls ‘body’ is similar to this (see my comment above for the exact definition):

def act = loop { react { body } }

The ‘loop’ method is looping and the act method never returns normally, e.g. constantly recurring.

There are two ways of modeling stateful actors:

1. Keep regular state in the actor (using ‘var’ or ‘val’) and make sure that you never publish a reference to it somehow, e.g. it should only be mutated from the actor main loop.

2. Create your own ‘loop’ and pass the state on recursively. E.g. something like this:

def act = {
  loop(new State)
}

def loop(state: State) {
  react {
    case Bla =>
      ... // use and / or update state
      loop(state)
  }
}

Makes sense?

I’m not ruling out I’ve completely misunderstood though, this all is still a bit new for me…

I agree that a library similar OTP is needed for Scala actors in order to write real-world actor-based server applications. Therefore this initial attempt

Scala actors have remote capabilities, however I not used it much myself. You are right that much of the power of Erlang comes with the location transparency, the ability to not only scale out on multi-core but also on multiple nodes. My next step will be to make sure that this works as expected.

…and yes, it only runs on the JVM. Scala has a port to .NET but this lib (and Scala actors package itself) is making use of some Java specific libraries such as java.util.concurrent.

You are right.

Conceptually, and from a user’s perspective, it is swapping the implementation of a method. But if you look at the implementation it is using a method on Scala’s PartialFunction (orElse) to chain pattern matching code. Such as:

  // the actor's main loop
  def act = loop { react { genericBase orElse actorBase } }

  // should we go with the hotswapped impl or the regular server impl (body)
  private def actorBase: PartialFunction[Any, Unit] = hotswap getOrElse body

  // the hotswapped impl
  private var hotswap: Option[PartialFunction[Any, Unit]] = None

  // generic functionality
  private val genericBase: PartialFunction[Any, Unit] = {
    case Init(config) => init(config)
    case HotSwap(code) => hotswap = code
    case Shutdown(reason) => shutdown(reason); reply('success)
    case Terminate(reason) => exit(reason)
  }

Scala, while being statically typed, has a feel of being dynamic and has such powerful constructs that you won’t actually miss “real” bytecode hotswapping. At least IMO.

Peace -stephan