Mutating methods for value types in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a mutating method that changes the value of a property.

Swift

struct Counter {
    var count = 0
    mutating func increment() {
        count [1] 1
    }
}

Drag options to blanks, or click blank then click option'

A+=

B-=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' to increment.

Not marking the method as mutating.

The increment method adds 1 to count using the += operator. This requires the method to be mutating because it changes the struct's property.

2fill in blank

medium

Complete the code to mark the method as mutating so it can modify the struct's property.

Swift

struct Point {
    var x = 0, y = 0
    [1] func moveBy(x deltaX: Int, y deltaY: Int) {
        x += deltaX
        y += deltaY
    }
}

Drag options to blanks, or click blank then click option'

Astatic

Bmutating

Cfinal

Doverride

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'static' which means the method belongs to the type, not instance.

Forgetting to mark the method as mutating.

The mutating keyword allows the method to change properties of the struct. Without it, the method cannot modify x and y.

3fill in blank

hard

Fix the error in the mutating method that tries to assign a new value to self.

Swift

struct Rectangle {
    var width: Int
    var height: Int
    mutating func doubleSize() {
        self [1] Rectangle(width: width * 2, height: height * 2)
    }
}

Drag options to blanks, or click blank then click option'

A-=

B==

C=

D+=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '=' causes a syntax error.

Trying to modify properties without marking the method as mutating.

Assigning a new value to self inside a mutating method requires the assignment operator =. Using == is a comparison and causes an error.

4fill in blank

hard

Fill both blanks to create a mutating method that resets the point to origin.

Swift

struct Point {
    var x: Int
    var y: Int
    [1] func reset() {
        x [2] 0
        y = 0
    }
}

Drag options to blanks, or click blank then click option'

Amutating

Bstatic

C+=

D=

Attempts:

3 left

💡 Hint

Common Mistakes

Not marking the method as mutating.

Using '+=' instead of '=' to reset the value.

The method must be marked mutating to change properties. To reset x, use the assignment operator = to set it to 0.

5fill in blank

hard

Fill all three blanks to create a mutating method that scales the size and updates the description.

Swift

struct Size {
    var width: Int
    var height: Int
    var description: String
    [1] func scale(by factor: Int) {
        width [2] width * factor
        height [3] height * factor
        description = "Scaled size"
    }
}

Drag options to blanks, or click blank then click option'

Amutating

B=

C+=

D*=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '*=' instead of '=' causes incorrect scaling logic here.

Not marking the method as mutating.

The method must be mutating to change properties. To update width and height, assign the new scaled values using =. The description is updated by assignment.

Practice

1. What is the purpose of the mutating keyword in Swift when used with methods inside a struct?

easy

A. It prevents the method from changing any properties.

B. It allows the method to modify properties of the struct.

C. It makes the method static and callable without an instance.

D. It marks the method as private and inaccessible outside the struct.

Solution

1. Step 1: Understand the role of mutating in structs

   In Swift, structs are value types and their properties cannot be changed inside instance methods unless the method is marked mutating.

2. Step 2: Effect of mutating keyword

   The mutating keyword allows the method to modify the struct's properties safely.

3. Final Answer:

   It allows the method to modify properties of the struct. -> Option B

4. Quick Check:

   mutating lets methods change struct data [OK]

Hint: Mutating means method can change struct's own properties [OK]

Common Mistakes:

• Thinking mutating makes method static
• Assuming mutating prevents changes
• Confusing mutating with access control

2. Which of the following is the correct syntax to declare a mutating method named updateValue inside a struct in Swift?

easy

A. mutating func updateValue() { }

B. func mutating updateValue() { }

C. func updateValue() mutating { }

D. mutate func updateValue() { }

Solution

1. Step 1: Recall correct order of keywords in method declaration

   In Swift, the mutating keyword comes before func when declaring a mutating method.

2. Step 2: Match the syntax

   mutating func updateValue() { } correctly shows mutating func updateValue() { }, which is the proper syntax.

3. Final Answer:

   mutating func updateValue() { } -> Option A

4. Quick Check:

   Keyword order: mutating before func [OK]

Hint: Put 'mutating' before 'func' in method declaration [OK]

Common Mistakes:

• Placing mutating after func
• Using 'mutate' instead of 'mutating'
• Adding mutating inside method body

3. Consider this Swift struct and code:

struct Counter {
    var count = 0
    mutating func increment() {
        count += 1
    }
}

var myCounter = Counter()
myCounter.increment()
print(myCounter.count)

What will be printed?

medium

A. 0

B. Runtime error

C. Compilation error

D. 1

Solution

1. Step 1: Understand the mutating method effect

   The increment() method is marked mutating, so it can increase the count property by 1.

2. Step 2: Trace the code execution

   We create myCounter as a variable instance, call increment(), so count changes from 0 to 1, then print outputs 1.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Mutating method changes count from 0 to 1 [OK]

Hint: Mutating methods change struct vars if instance is variable [OK]

Common Mistakes:

• Expecting 0 because method looks like a function
• Thinking mutating methods cause errors always
• Using constant instance instead of variable

4. Given this Swift code:

struct Point {
    var x = 0
    var y = 0
    mutating func moveTo(newX: Int, newY: Int) {
        x = newX
        y = newY
    }
}

let p = Point()
p.moveTo(newX: 10, newY: 20)

What is the problem here?

medium

A. The method moveTo is missing the mutating keyword.

B. Structs cannot have methods that change properties.

C. Cannot call mutating method on a constant instance.

D. The properties x and y must be declared as constants.

Solution

1. Step 1: Identify instance mutability

   The instance p is declared with let, making it a constant.

2. Step 2: Understand mutating method call on constant

   Mutating methods cannot be called on constant instances because they change properties, which is not allowed.

3. Final Answer:

   Cannot call mutating method on a constant instance. -> Option C

4. Quick Check:

   Mutating methods need variable instances [OK]

Hint: Mutating methods require variable (var) instances, not constants [OK]

Common Mistakes:

• Thinking mutating keyword is missing
• Believing structs can't have mutating methods
• Assuming properties must be constants

5. You want to create a Swift struct BankAccount with a balance property. You need a mutating method deposit(amount:) that adds money to the balance only if the amount is positive. Which implementation correctly uses a mutating method to safely update the balance?

hard

A. struct BankAccount {
var balance: Double = 0
mutating func deposit(amount: Double) {
if amount > 0 {
balance += amount
}
}
}

B. struct BankAccount {
var balance: Double = 0
func deposit(amount: Double) {
if amount > 0 {
balance += amount
}
}
}

C. struct BankAccount {
let balance: Double = 0
mutating func deposit(amount: Double) {
balance += amount
}
}

D. struct BankAccount {
var balance: Double = 0
mutating func deposit(amount: Double) {
balance = amount
}
}

Solution

1. Step 1: Check mutating method and property mutability

   The method must be marked mutating to change balance, which must be a variable (var), not constant.

2. Step 2: Verify correct logic for deposit

   struct BankAccount { var balance: Double = 0 mutating func deposit(amount: Double) { if amount > 0 { balance += amount } } } adds amount only if positive, correctly updating balance. struct BankAccount { var balance: Double = 0 func deposit(amount: Double) { if amount > 0 { balance += amount } } } lacks mutating, so it cannot change balance. struct BankAccount { let balance: Double = 0 mutating func deposit(amount: Double) { balance += amount } } uses let for balance, so it cannot be changed. struct BankAccount { var balance: Double = 0 mutating func deposit(amount: Double) { balance = amount } } replaces balance with amount without checking positivity.

3. Final Answer:

   struct BankAccount { var balance: Double = 0 mutating func deposit(amount: Double) { if amount > 0 { balance += amount } } } -> Option A

4. Quick Check:

   Mutating method + var property + condition = correct [OK]

Hint: Mutating method must change var property with proper checks [OK]

Common Mistakes:

• Forgetting mutating keyword
• Using let instead of var for properties
• Not checking if amount is positive