Actor declaration syntax in Swift

Introduction

Actors help keep your program safe when many parts try to change data at the same time. They make sure only one part can change data at once.

When you want to protect data from being changed by many parts of your program at the same time.

When you write code that works with tasks running at the same time and need to avoid mistakes.

When you want to organize code that manages shared information safely.

When you want to use Swift's built-in way to handle safe data access in concurrent programs.

Syntax

Swift

actor ActorName {
    // properties and methods
}

The keyword actor declares a special type that protects its data.

Inside the actor, you write properties and methods like in a class.

Examples

This actor keeps a number and can increase it safely.

Swift

actor Counter {
    var value = 0

    func increment() {
        value += 1
    }
}

This actor manages money safely, allowing deposits and withdrawals.

Swift

actor BankAccount {
    var balance: Double = 0.0

    func deposit(amount: Double) {
        balance += amount
    }

    func withdraw(amount: Double) -> Bool {
        if balance >= amount {
            balance -= amount
            return true
        } else {
            return false
        }
    }
}

Sample Program

This program creates an actor that stores temperature. It safely updates and reads the temperature using async calls.

Swift

import Foundation

actor TemperatureSensor {
    var temperature: Double = 20.0

    func updateTemperature(to newTemp: Double) {
        temperature = newTemp
    }

    func readTemperature() -> Double {
        return temperature
    }
}

@main
struct Main {
    static func main() async {
        let sensor = TemperatureSensor()
        await sensor.updateTemperature(to: 25.5)
        let currentTemp = await sensor.readTemperature()
        print("Current temperature is \(currentTemp)°C")
    }
}

Important Notes

Actors use await when calling their methods because they work asynchronously.

Actors help avoid problems when many parts of your program try to change data at the same time.

Summary

Actors are special types that protect data in concurrent programs.

Use the actor keyword to declare them.

Call actor methods with await to safely access or change data.

Practice

1. What keyword is used to declare an actor in Swift?

easy

A. class

B. enum

C. struct

D. actor

Solution

1. Step 1: Understand actor declaration

   Actors in Swift are declared using a special keyword to indicate their concurrency-safe nature.

2. Step 2: Identify the correct keyword

   The keyword actor is used to declare actors, differentiating them from classes, structs, or enums.

3. Final Answer:

   actor -> Option D

4. Quick Check:

   Actor declaration keyword = actor [OK]

Hint: Actors always start with the keyword 'actor' [OK]

Common Mistakes:

• Using class instead of actor
• Confusing struct with actor
• Trying to declare actor with enum

2. Which of the following is the correct syntax to declare an actor named DataManager?

easy

A. actor DataManager() { }

B. actor DataManager { }

C. struct DataManager { }

D. class DataManager { }

Solution

1. Step 1: Recall actor declaration syntax

   Actors are declared with the keyword actor followed by the name and curly braces without parentheses.

2. Step 2: Check each option

   actor DataManager { } uses correct syntax: actor DataManager { }. actor DataManager() { } incorrectly adds parentheses after the name.

3. Final Answer:

   actor DataManager { } -> Option B

4. Quick Check:

   Correct actor syntax = actor Name { } [OK]

Hint: Actors do not use parentheses after their name [OK]

Common Mistakes:

• Adding parentheses after actor name
• Using class or struct instead of actor
• Omitting curly braces

3. What will be the output of the following Swift code?

actor Counter {
    var value = 0
    func increment() {
        value += 1
    }
}

let counter = Counter()
Task {
    await counter.increment()
    print(await counter.value)
}

medium

A. 1

B. 0

C. Compilation error

D. Runtime error

Solution

1. Step 1: Understand actor behavior and method calls

   The actor Counter has a variable value initialized to 0 and a method increment() that adds 1 to value. The method is called with await inside a Task.

2. Step 2: Trace the code execution

   The increment() method increases value from 0 to 1. Then print(await counter.value) prints the updated value, which is 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Incremented value = 1 [OK]

Hint: Remember to await actor method calls and property access [OK]

Common Mistakes:

• Forgetting to use await with actor calls
• Expecting initial value 0 after increment
• Assuming synchronous access to actor properties

4. Identify the error in the following actor declaration and fix it:

actor Logger {
    var logs: [String]
    func addLog(_ message: String) {
        logs.append(message)
    }
}

medium

A. Missing initialization of 'logs' array

B. Actor cannot have functions

C. Use 'class' instead of 'actor'

D. Missing 'await' keyword in function

Solution

1. Step 1: Check property initialization in actor

   The property logs is declared but not initialized. In Swift, stored properties must have initial values or be initialized in an initializer.

2. Step 2: Identify the fix

   Initialize logs as an empty array: var logs: [String] = [] to fix the error.

3. Final Answer:

   Missing initialization of 'logs' array -> Option A

4. Quick Check:

   Stored properties need initial values [OK]

Hint: Always initialize stored properties in actors [OK]

Common Mistakes:

• Assuming default initialization for arrays
• Thinking actors cannot have functions
• Forgetting to add await when calling actor methods

5. You want to create an actor BankAccount that safely manages a balance. Which of the following code snippets correctly declares the actor and provides a method to deposit money asynchronously?

hard

A. actor BankAccount {
var balance: Double = 0.0
func deposit(amount: Double) {
balance += amount
}
}

B. actor BankAccount {
var balance: Double = 0.0
func deposit(amount: Double) {
await balance += amount
}
}

C. actor BankAccount {
var balance: Double = 0.0
func deposit(amount: Double) async {
await Task.sleep(1_000_000_000)
balance += amount
}
}

D. class BankAccount {
var balance: Double = 0.0
func deposit(amount: Double) async {
balance += amount
}
}

Solution

1. Step 1: Understand actor method concurrency

   Actor methods that perform asynchronous work should be marked async. actor BankAccount { var balance: Double = 0.0 func deposit(amount: Double) { balance += amount } } lacks async on the method, so it cannot await inside.

2. Step 2: Check for realistic async behavior

   actor BankAccount { var balance: Double = 0.0 func deposit(amount: Double) async { await Task.sleep(1_000_000_000) balance += amount } } marks deposit as async and simulates asynchronous delay with await Task.sleep(), showing proper async usage inside an actor.

3. Step 3: Verify actor declaration

   class BankAccount { var balance: Double = 0.0 func deposit(amount: Double) async { balance += amount } } uses class instead of actor, so it does not provide concurrency safety.

4. Final Answer:

   correctly declares an actor with an async deposit method including await -> Option C

5. Quick Check:

   Actor + async method + await inside = actor BankAccount { var balance: Double = 0.0 func deposit(amount: Double) async { await Task.sleep(1_000_000_000) balance += amount } } [OK]

Hint: Async actor methods must be marked async and use await inside [OK]

Common Mistakes:

• Omitting async keyword on async actor methods
• Using class instead of actor for concurrency
• Not using await inside async methods when needed