If scala advocate immutability why it adopted actor model with its mutable nature? [closed]

Question

I am new in scala and actor world.

This is what I've learned so far:

Scala is functional programming (not purely) and people advice not to use mutable state in scala.

But on another hand, there is akka framework which implements actor model. And during playing with akka I realized that the messages are immutable, BUT the state of the actors in MUTABLE. So, I need to specify inside of actors "var" variables and mutable collections. And, for me, to have a mutable state is not natural for scala.

So, does my understanding correct? Why do people adopted mutable actors model in immutable scala language?

Answer 1

This is an interesting point and indeed actors are quite different from the rest of Scala-like code.

You can think of actors as a replacement for threads with locks, semaphores and the rest. It is a more intuitive and performant model of concurrent programming since mutable state is always encapsulated in an actor that processes messages sequentially.

It provides a solid bedrock to build more functional abstractions. Akka team has produced akka-streams. Spark is using akka to communicate across nodes. Futures, another successful functional alternative to the problem is essentially a special case of streams: a stream of exactly one element and could be implemented using actors.

So, people use actors because some problems are solved more intuitively by having actors messaging each other than with operations on streams. Since the main argument against mutability is the complete mess it creates on concurrency, and actors solve exactly this, I guess it is okay to have this mutability. They are rather complex, but the proper solution to concurrency is actually this complex.

And just a note, streams are arguably the functional way to model any interaction of a program with its environment. E.g. for GUI development, you could provide all triggered events of controls as a stream, and folding the stream is essentially creating a way to manage the state of the program.

Answer 2

Scala is a language that allows mixed models. It is trues that most examples use mutable state inside Actors but you can use Actors with immutable state using become :

class ListActor extends Actor {
  def receive = changeState(List.empty[String])

  def changeState(state: List[String]): Receive = {
    case Add(item) =>
      context.become(changeState(item :: state))
  }
}

Answer 3

That's a good question with an interesting answer (IMHO): Scala is not functional. It's post-functional. Which means it unifies object oriented and functional programming into a single paradigm.

Within this framework, Scala favors immutability, but does not enforce it. The Actor model is one place where mutability makes sense, as all changes are local, the coordination of the concurrent behavior is done for you by the actor system.