Distributed actors overview in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple distributed actor method call

What is the output of this Swift code using a distributed actor?

Swift

distributed actor Counter {
    var value = 0
    distributed func increment() async {
        value += 1
    }
    func current() -> Int {
        return value
    }
}

func test() async {
    let counter = Counter()
    await counter.increment()
    print(counter.current())
}

task {
    await test()
}

A 1

B Runtime error

C Compilation error

D 0

💡 Hint

Remember that distributed functions are asynchronous and may not update local state immediately.

The distributed func increment() is asynchronous and runs remotely, so the local value is not updated immediately. The current() method returns the local value, which remains 0.

🧠 Conceptual

intermediate

Understanding the role of distributed actor identity

What is the main purpose of the identity property in a distributed actor?

A To store the actor's internal state

B To uniquely identify the actor instance across the network

C To define the actor's concurrency model

D To manage local memory allocation

💡 Hint

Think about how distributed actors communicate remotely.

The identity property uniquely identifies a distributed actor instance across the network, allowing remote calls to be routed correctly.

🔧 Debug

advanced

Identify the error in distributed actor initialization

What error will this code produce and why?

Swift

distributed actor Logger {
    let id: UUID
    init() {
        id = UUID()
    }
}

func test() {
    let logger = Logger()
}

A No error, code runs fine

B Runtime error: missing actor system

C Compilation error: distributed actors require a distributed actor system parameter in init

D Compilation error: distributed actors cannot have stored properties

💡 Hint

Distributed actors need a system to manage their identity and communication.

Distributed actors require an actor system parameter in their initializer to manage identity and remote communication. The code lacks this parameter, causing a compilation error.

📝 Syntax

advanced

Correct syntax for distributed function declaration

Which option correctly declares a distributed function in a distributed actor?

Swift

distributed actor Service {
    ???
}

A distributed func fetchData() async throws -> String

B func distributed fetchData() async throws -> String

C distributed func fetchData() -> String

D func fetchData() distributed async throws -> String

💡 Hint

The 'distributed' keyword comes before 'func'.

The correct syntax places 'distributed' before 'func' and supports async and throws modifiers.

🚀 Application

expert

Predict the number of items in a distributed actor's dictionary after remote calls

Given this distributed actor code, how many key-value pairs will the dictionary contain after the calls?

Swift

distributed actor Store {
    var items: [String: Int] = [:]
    distributed func addItem(key: String, value: Int) async {
        items[key] = value
    }
    func countItems() -> Int {
        return items.count
    }
}

func test() async {
    let store = Store()
    await store.addItem(key: "a", value: 1)
    await store.addItem(key: "b", value: 2)
    print(store.countItems())
}

task {
    await test()
}

A 0

B 1

C Compilation error

D 2

💡 Hint

Distributed functions run remotely and do not update local state immediately.

The distributed func addItem runs remotely and updates the remote state, but the local 'items' dictionary remains empty. The countItems() method returns the local count, which is 0.

Practice

1. What is the main purpose of a distributed actor in Swift?

easy

A. To define a class that cannot be used with concurrency

B. To create a local-only actor with no network communication

C. To allow an actor to work across multiple computers easily

D. To replace all functions with synchronous calls

Solution

1. Step 1: Understand the role of distributed actors

   Distributed actors are designed to work across different machines, enabling remote communication.

2. Step 2: Compare options with the concept

   Only To allow an actor to work across multiple computers easily correctly describes this purpose; others describe unrelated or incorrect features.

3. Final Answer:

   To allow an actor to work across multiple computers easily -> Option C

4. Quick Check:

   Distributed actor purpose = cross-computer use [OK]

Hint: Distributed actors enable remote work across computers [OK]

Common Mistakes:

• Thinking distributed actors are local-only
• Confusing distributed actors with regular classes
• Assuming distributed actors disable concurrency

2. Which of the following is the correct way to declare a distributed function inside a distributed actor?

easy

A. func fetchData() async throws -> String

B. func distributed fetchData() async throws -> String

C. distributed func fetchData() -> String

D. distributed func fetchData() async throws -> String

Solution

1. Step 1: Recall distributed function syntax

   Distributed functions inside distributed actors use the keyword distributed func and are usually async and throwable.

2. Step 2: Check each option

   distributed func fetchData() async throws -> String matches the correct syntax exactly. func fetchData() async throws -> String misses the distributed keyword. distributed func fetchData() -> String misses async and throws. func distributed fetchData() async throws -> String has incorrect keyword order.

3. Final Answer:

   distributed func fetchData() async throws -> String -> Option D

4. Quick Check:

   Distributed function syntax = distributed func [OK]

Hint: Use 'distributed func' keyword for remote calls [OK]

Common Mistakes:

• Omitting 'distributed' keyword
• Placing 'distributed' after 'func'
• Forgetting async or throws in distributed funcs

3. Given the code below, what will be printed when calling await greeter.sayHello()?

distributed actor Greeter {
    distributed func sayHello() async -> String {
        return "Hello from distributed actor!"
    }
}

let greeter = Greeter()
Task {
    let message = await greeter.sayHello()
    print(message)
}

medium

A. Error: distributed actor cannot be instantiated directly

B. Hello from distributed actor!

C. Hello from local actor!

D. Runtime error due to missing network connection

Solution

1. Step 1: Understand distributed actor instantiation

   Distributed actors can be instantiated locally for testing or local use, so Greeter() is valid here.

2. Step 2: Analyze the distributed function call

   The sayHello() function returns the string "Hello from distributed actor!" asynchronously, so the print will output this string.

3. Final Answer:

   Hello from distributed actor! -> Option B

4. Quick Check:

   Distributed func returns greeting string [OK]

Hint: Distributed actors can be called locally for testing [OK]

Common Mistakes:

• Assuming distributed actors cannot be instantiated locally
• Expecting network errors without remote setup
• Confusing distributed actor with local-only actor

4. Identify the error in the following distributed actor code:

distributed actor Counter {
    var count = 0

    distributed func increment() {
        count += 1
    }
}

medium

A. Distributed functions must be async and throwable

B. Distributed actors cannot have mutable state

C. The distributed func must return a value

D. The count variable must be declared as distributed

Solution

1. Step 1: Check distributed function requirements

   Distributed functions must be declared as async and can throw errors because they involve remote calls.

2. Step 2: Analyze the given function

   The increment() function is missing async and throws keywords, which is a syntax error for distributed functions.

3. Final Answer:

   Distributed functions must be async and throwable -> Option A

4. Quick Check:

   Distributed func requires async and throws [OK]

Hint: Always add async and throws to distributed funcs [OK]

Common Mistakes:

• Forgetting async keyword in distributed funcs
• Assuming distributed funcs can be synchronous
• Thinking distributed actors disallow mutable vars

5. You want to build a distributed chat app using Swift's distributed actors. Which approach correctly uses distributed actors and functions to send a message to a remote user?

hard

A. Define a distributed actor ChatUser with a distributed func sendMessage(_ message: String) that can be called remotely.

B. Use a regular class with async functions and manually handle network communication.

C. Define a distributed actor but use non-distributed functions for sending messages.

D. Use global functions with no actors to send messages asynchronously.

Solution

1. Step 1: Understand distributed actors for remote communication

   Distributed actors are designed to simplify remote calls, so defining a ChatUser as a distributed actor with distributed functions fits the use case.

2. Step 2: Evaluate options for remote message sending

   Define a distributed actor ChatUser with a distributed func sendMessage(_ message: String) that can be called remotely. correctly uses distributed actors and distributed functions for remote calls. Options B, C, and D either ignore distributed actors or misuse function types, making remote communication harder or incorrect.

3. Final Answer:

   Define a distributed actor ChatUser with a distributed func sendMessage(_ message: String) that can be called remotely. -> Option A

4. Quick Check:

   Distributed actors + distributed funcs = remote calls [OK]

Hint: Use distributed actors with distributed funcs for remote calls [OK]

Common Mistakes:

• Using regular classes instead of distributed actors
• Calling non-distributed functions remotely
• Ignoring actor isolation and concurrency