Model definition with @Model in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding @Model property wrapper usage

What is the primary purpose of using the @Model property wrapper in SwiftUI apps?

A To automatically manage the lifecycle and persistence of data models in the app.

B To create a user interface element that displays model data.

C To define a function that updates the UI when data changes.

D To style views with custom colors and fonts.

💡 Hint

Think about how data is stored and updated in SwiftUI apps.

The @Model property wrapper is used to mark data models that SwiftUI manages automatically, including saving and updating them.

❓ ui_behavior

intermediate

Effect of @Model on UI updates

Given a SwiftUI view with a @Model property, what happens when a property inside the model changes?

A The view ignores the change until manually refreshed.

B The view automatically refreshes to reflect the updated data.

C The app crashes due to data inconsistency.

D The model resets to its initial state.

💡 Hint

Consider how SwiftUI reacts to changes in observed data.

@Model notifies SwiftUI about data changes, triggering UI updates automatically.

📝 Syntax

advanced

Correct syntax for defining a @Model struct

Which of the following code snippets correctly defines a Swift data model using @Model?

iOS Swift

Choose the correct code snippet:

A

import SwiftUI
struct Task {
  @Model var title: String
  @Model var isDone: Bool
}

B

import SwiftUI
@Model
class Task {
  var title: String
  var isDone: Bool
}

C

import SwiftUI
@Model
struct Task {
  var title: String
  var isDone: Bool
}

D

import SwiftUI
@Model
struct Task {
  let title: String
  let isDone: Bool
}

💡 Hint

Remember @Model is applied to the whole struct, not individual properties.

The @Model attribute is placed before the struct declaration. Properties inside should be vars to allow changes.

❓ lifecycle

advanced

Persistence behavior of @Model data

When you mark a struct with @Model, what happens to instances of this model when the app is closed and reopened?

A The app throws an error on launch due to missing data.

B The data is lost and resets to default values.

C The data is saved only if manually written to a file.

D The data is automatically saved and restored across app launches.

💡 Hint

Think about what automatic persistence means for user data.

@Model enables automatic persistence, so data remains available after app restarts.

🔧 Debug

expert

Identifying error with @Model usage

What error will occur if you define a @Model struct with a property marked as let instead of var?

iOS Swift

import SwiftUI
@Model
struct Note {
  let content: String
}

A Compilation error: Properties in a @Model struct must be mutable (var).

B No error; let properties are allowed in @Model structs.

C Runtime error: Cannot modify immutable property.

D Warning: Property will not be saved persistently.

💡 Hint

Consider how @Model tracks changes to properties.

@Model requires properties to be mutable so it can track and save changes. Using let causes a compile-time error.

Practice

1. What is the main purpose of using @Model in SwiftUI?

easy

A. To mark a class as a data container for app state

B. To create a user interface element

C. To define a function for navigation

D. To style text in the app

Solution

1. Step 1: Understand the role of @Model

   @Model is used to mark a class that holds data for the app, making it a data container.

2. Step 2: Differentiate from UI or styling

   @Model does not create UI elements or style text; it only defines data structures.

3. Final Answer:

   To mark a class as a data container for app state -> Option A

4. Quick Check:

   @Model = data container [OK]

Hint: Remember: @Model is for data, not UI or styling [OK]

Common Mistakes:

• Thinking @Model creates UI components
• Confusing @Model with styling attributes
• Assuming @Model defines functions

2. Which of the following is the correct syntax to define a model class with @Model in Swift?

easy

A. class User { @Model var name: String }

B. class @Model User { var name: String }

C. class User @Model { var name: String }

D. @Model class User { var name: String }

Solution

1. Step 1: Recall correct @Model placement

   @Model is placed before the class keyword to mark the entire class as a model.

2. Step 2: Check other options for syntax errors

   Other placements of @Model cause syntax errors.

3. Final Answer:

   @Model class User { var name: String } -> Option D

4. Quick Check:

   @Model before class = correct syntax [OK]

Hint: Put @Model right before class keyword [OK]

Common Mistakes:

• Placing @Model after class name
• Adding @Model before property instead of class
• Using @Model inside class body

3. Given the model definition:

@Model class Task { var title: String; var done: Bool }

What is the output of this code?

let task = Task(title: "Buy milk", done: false)
print(task.done)

medium

A. true

B. false

C. nil

D. Compilation error

Solution

1. Step 1: Understand model initialization

   The Task model is initialized with done set to false (@Model synthesizes the initializer).

2. Step 2: Print the done property value

   Printing task.done outputs the Boolean value false.

3. Final Answer:

   false -> Option B

4. Quick Check:

   task.done = false [OK]

Hint: Check property values passed during initialization [OK]

Common Mistakes:

• Assuming default true value for done
• Expecting nil instead of false
• Thinking @Model changes property defaults

4. Identify the error in this model definition:

@Model class Product {
  var name: String
  var price: Double
  func discount() -> Double {
    return price * 0.9
  }
}

medium

A. No error, this is valid

B. Models cannot have functions inside them

C. price should be an Int, not Double

D. Missing initializer for properties

Solution

1. Step 1: Check @Model class rules

   @Model classes are data containers that support stored properties, computed properties, initializers (synthesized), and methods.

2. Step 2: Analyze potential issues

   No syntax errors: initializer synthesized by @Model, Double valid for price, methods allowed.

3. Final Answer:

   No error, this is valid -> Option A

4. Quick Check:

   @Model class = supports methods [OK]

Hint: @Model classes support methods [OK]

Common Mistakes:

• Thinking @Model prohibits functions
• Believing explicit initializer always required
• Insisting price must be Int

5. You want to create a model to store user profile data with a name and optional age. Which is the best way to define it using @Model?

hard

A. @Model class UserProfile { var name: String; var age: Optional<Int> }

B. @Model class UserProfile { var name: String; var age: Int = nil }

C. @Model class UserProfile { var name: String; var age: Int? }

D. @Model class UserProfile { var name: String; var age: Int! }

Solution

1. Step 1: Understand optional property syntax

   In Swift, optional properties are declared with a question mark, e.g., Int?.

2. Step 2: Evaluate each option's correctness

   @Model class UserProfile { var name: String; var age: Int? } uses correct, idiomatic optional syntax. @Model class UserProfile { var name: String; var age: Int = nil } assigns nil to a non-optional Int, which is invalid. @Model class UserProfile { var name: String; var age: Optional<Int> } uses verbose Optional<Int>. @Model class UserProfile { var name: String; var age: Int! } uses implicitly unwrapped optional which is less safe.

3. Final Answer:

   @Model class UserProfile { var name: String; var age: Int? } -> Option C

4. Quick Check:

   Optional property = Int? [OK]

Hint: Use ? for optional properties in models [OK]

Common Mistakes:

• Assigning nil to non-optional types
• Using wrong optional syntax
• Using implicitly unwrapped optionals unnecessarily