Scala actors: receive vs react
Let me first say that I have quite a lot of Java experience, but have only recently become interested in functional languages. Recently I've started looking at Scala, which seems like a very nice language.

However, I've been reading about Scala's Actor framework in [_Programming in Scala_](http://www.artima.com/shop/programming_in_scala), and there's one thing I don't understand. In chapter 30.4 it says that using `react` instead of `receive` makes it possible to re-use threads, which is good for performance, since threads are expensive in the JVM.

Does this mean that, as long as I remember to call `react` instead of `receive`, I can start as much Actors as I like? Before discovering Scala, I've been playing with Erlang, and the author of [_Programming Erlang_](http://www.pragprog.com/titles/jaerlang/programming-erlang) boasts about spawning over 200,000 processes without breaking a sweat. I'd hate to do that with Java threads. What kind of limits am I looking at in Scala as compared to Erlang (and Java)?

Also, how does this thread re-use work in Scala? Let's assume, for simplicity, that I have only one thread. Will all the actors that I start run sequentially in this thread, or will some sort of task-switching take place? For example, if I start two actors that ping-pong messages to each other, will I risk deadlock if they're started in the same thread?

According to _Programming in Scala_, writing actors to use `react` is more difficult than with `receive`. This sounds plausible, since `react` doesn't return. However, the book goes on to show how you can put a `react` inside a loop using `Actor.loop`. As a result, you get

    loop {
        react {
            ...
        }
    }

which, to me, seems pretty similar to

    while (true) {
        receive {
            ...
        }
    }

which is used earlier in the book. Still, the book says that "in practice, programs will need at least a few `receive`'s". So what am I missing here? What can `receive` do that `react` cannot, besides return? And why do I care?

Finally, coming to the core of what I don't understand: the book keeps mentioning how using `react` makes it possible to discard the call stack to re-use the thread. How does that work? Why is it necessary to discard the call stack? And why can the call stack be discarded when a function terminates by throwing an exception (`react`), but not when it terminates by returning (`receive`)?

I have the impression that _Programming in Scala_ has been glossing over some of the key issues here, which is a shame, because otherwise it's a truly excellent book.


Scala actors: receive vs react
===

Let me first say that I have quite a lot of Java experience, but have only recently become interested in functional languages. Recently I've started looking at Scala, which seems like a very nice language.

However, I've been reading about Scala's Actor framework in [_Programming in Scala_](http://www.artima.com/shop/programming_in_scala), and there's one thing I don't understand. In chapter 30.4 it says that using `react` instead of `receive` makes it possible to re-use threads, which is good for performance, since threads are expensive in the JVM.

Does this mean that, as long as I remember to call `react` instead of `receive`, I can start as much Actors as I like? Before discovering Scala, I've been playing with Erlang, and the author of [_Programming Erlang_](http://www.pragprog.com/titles/jaerlang/programming-erlang) boasts about spawning over 200,000 processes without breaking a sweat. I'd hate to do that with Java threads. What kind of limits am I looking at in Scala as compared to Erlang (and Java)?

Also, how does this thread re-use work in Scala? Let's assume, for simplicity, that I have only one thread. Will all the actors that I start run sequentially in this thread, or will some sort of task-switching take place? For example, if I start two actors that ping-pong messages to each other, will I risk deadlock if they're started in the same thread?

According to _Programming in Scala_, writing actors to use `react` is more difficult than with `receive`. This sounds plausible, since `react` doesn't return. However, the book goes on to show how you can put a `react` inside a loop using `Actor.loop`. As a result, you get

    loop {
        react {
            ...
        }
    }

which, to me, seems pretty similar to

    while (true) {
        receive {
            ...
        }
    }

which is used earlier in the book. Still, the book says that "in practice, programs will need at least a few `receive`'s". So what am I missing here? What can `receive` do that `react` cannot, besides return? And why do I care?

Finally, coming to the core of what I don't understand: the book keeps mentioning how using `react` makes it possible to discard the call stack to re-use the thread. How does that work? Why is it necessary to discard the call stack? And why can the call stack be discarded when a function terminates by throwing an exception (`react`), but not when it terminates by returning (`receive`)?

I have the impression that _Programming in Scala_ has been glossing over some of the key issues here, which is a shame, because otherwise it's a truly excellent book.

