Usage of state in updateState method (Persistent Actor) - scala

Question

From Akka Cookbook, example from chapter Persistent Actors. In SamplePersistentActor.scala there is line of code that I don't quite understand. Here's the full code of 2 files.
SamplePersistentActor.scala:
class SamplePersistenceActor extends PersistentActor {
override val persistenceId = "unique-id-1"
var state = ActiveUsers()
def updateState(event:Event) = state = state.update(event)
val receiveRecover: Receive = {
case evt: Event => updateState(evt)
case SnapshotOffer(_, snapshot: ActiveUsers) => state = snapshot
}
override val receiveCommand: Receive = {
case UserUpdate(userId, Add) =>
persist(AddUserEvent(userId))(updateState)
case UserUpdate(userId, Remove) =>
persist(RemoveUserEvent(userId))(updateState)
case "snap" => saveSnapshot(state)
case "print" => println(state)
}
}
SamplePersistentModel.scala:
sealed trait UserAction
case object Add extends UserAction
case object Remove extends UserAction
case class UserUpdate(userId: String, action: UserAction)
sealed trait Event
case class AddUserEvent(userId: String) extends Event
case class RemoveUserEvent(userId: String) extends Event
case class ActiveUsers(users: Set[String] = Set.empty[String])
{
def update(evt: Event)= evt match {
case AddUserEvent(userId) => copy(users + userId)
case RemoveUserEvent(userId) => copy(users.filterNot(_ == userId))
}
override def toString = s"$users"
}
My question
What is the purpose of = state (or = this.state if I'm correct) in line def updateState(event:Event) = state = state.update(event). Why can't we just use def updateState(event:Event) = state.update(event)?
Found similar in documentation example.

Answer 1

In your sample code:
def updateState(event: Event) = state = state.update(event)
is equivalent to:
def updateState(event: Event) = { state = state.update(event) }
So, updateState is a function of Event => Unit, which is exactly what method persist expects as its second parameter:
persist(AddUserEvent(userId))(updateState)
Below is the signature of method persist in Akka PersistentActor:
trait PersistentActor extends Eventsourced with PersistenceIdentity {
// ...
def persist[A](event: A)(handler: A => Unit): Unit = {
internalPersist(event)(handler)
}
// ...
}
It expects a EventType => Unit handler code block as its second parameter to handle specific persistence business logic that generally involves updating internal states of the actor.

Answer 2

Why can't we just use def updateState(event:Event) = state.update(event)?
The reason for the reassignment to the state variable is that update creates a new object. In other words, calling state.update doesn't mutate state; it makes a copy of state with the updated information.
This is the case with the example that you referenced:
var state = ExampleState()
def updateState(event: Evt): Unit =
state = state.updated(event)
Looking at the code for ExampleState, we see that the updated method actually creates a new ExampleState object:
def updated(evt: Evt): ExampleState = copy(evt.data :: events)