Distributed actors overview in Swift - Step-by-Step Execution

Concept Flow - Distributed actors overview

Define distributed actor

↓

Create instance locally or remotely

↓

Call method on distributed actor

↓

System routes call

↓

If local: execute directly

↓

If remote: send message over network

↓

Receive response

↓

Return result to caller

This flow shows how a distributed actor is defined, created, and how method calls are routed either locally or remotely, with results returned to the caller.

Execution Sample

Swift

distributed actor ChatRoom {
    distributed func sendMessage(_ msg: String) async -> Bool {
        print("Sending: \(msg)")
        return true
    }
}

let room = ChatRoom()
let success = await room.sendMessage("Hello")

Defines a distributed actor ChatRoom, creates an instance, and calls a method asynchronously.

Execution Table

Step	Action	Evaluation	Result
1	Define distributed actor ChatRoom	Distributed actor type created	ChatRoom type ready
2	Create instance room = ChatRoom()	Instance created locally	room is local ChatRoom actor
3	Call await room.sendMessage("Hello")	Check if room is local or remote	room is local
4	Execute sendMessage locally	Print message	Output: Sending: Hello
5	Return true from sendMessage	Result true	success = true
6	End of execution	All steps done	Program complete

💡 Execution stops after method call returns and result is assigned

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
room	undefined	local ChatRoom instance	local ChatRoom instance	local ChatRoom instance
success	undefined	undefined	true	true

Key Moments - 3 Insights

Why does the method call use 'await'?

Because distributed actor methods are asynchronous, the call may involve waiting for a remote response. See execution_table step 3 and 4 where the call is awaited.

How does the system know if the actor is local or remote?

The system tracks actor location internally. In step 3, it checks if 'room' is local or remote to decide how to execute the method.

What happens if the actor was remote?

The system would send a network message instead of direct execution. This is shown in the concept_flow where calls route differently for remote actors.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'success' after step 5?

A false

B undefined

C true

D nil

💡 Hint

Check the 'Result' column in row for step 5 in execution_table

At which step does the system decide if the actor is local or remote?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Evaluation' columns in execution_table step 3

If the actor was remote, what would change in the execution flow?

A The method would execute locally without network

B The system would send a network message instead of direct call

C The actor instance would be undefined

D The method would not return any result

💡 Hint

Refer to concept_flow where remote calls send messages over network

Concept Snapshot

distributed actor TypeName {
    distributed func someMethod() async {}
}

- Distributed actors can run locally or remotely.
- Calls to distributed actors are async and use 'await'.
- System routes calls: local executes directly, remote sends network message.
- Results return asynchronously to caller.

Full Transcript

This visual execution trace shows how distributed actors work in Swift. First, a distributed actor type is defined. Then an instance is created locally. When calling a method on the actor, the system checks if the actor is local or remote. If local, the method runs directly. If remote, the call is sent over the network. The method returns asynchronously, so calls use 'await'. Variables like the actor instance and result track their values step-by-step. Key moments clarify why 'await' is needed and how location affects execution. Quiz questions test understanding of variable values and flow decisions.