What we want to emulate, Scala’s nested receive:

case object Message1
case object Message2
case object NestedMessage1
case object NestedMessage2

receive {
  case Message1 => 
    ... // process step 1

    receive {
      case NestedMessage1 => 
        ... // process
      case NestedMessage2 => 
        ... // process
    }

  case Message2 => 
    ... // process
}

============
My proposed API:

class MyActor extends ActorWithNestedReceive {
  def react = {
    case Message1 => 
      ... // process
      reactAgain { 
        case NestedMessage1 =>
          ... // process
        case NestedMessage2 =>
          ... // process 
      }

    case Message2 => 
      ... // process
  }
}

============
How to implement it:

trait ActorWithNestedReceive extends Actor {
  import Actor.actor
  private var nestedReactsProcessors: List[ActorRef] = Nil
  private val processNestedReacts: PartialFunction[Any, Unit] = {
    case message if !nestedReactsProcessors.isEmpty =>
      val processors = nestedReactsProcessors.reverse
      processors.head forward message
      nestedReactsProcessors = processors.tail.reverse
  }
 
  protected def react: PartialFunction[Any, Unit]
  protected def reactAgain(pf: PartialFunction[Any, Unit]) = nestedReactsProcessors ::= actor(pf)
  protected def receive = processNestedReacts orElse react
}