Repository pattern in iOS Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a protocol for the repository.

iOS Swift

protocol UserRepository {
    func fetchUser(id: Int) -> [1]
}

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

AInt

BUser?

CString

DVoid

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a String or Int instead of a User object.

Using Void as return type which means no value returned.

The repository protocol should define a method that returns an optional User object when fetching by id.

2fill in blank

medium

Complete the code to implement the repository class conforming to the protocol.

iOS Swift

class UserRepositoryImpl: UserRepository {
    func fetchUser(id: Int) -> [1] {
        // Implementation
        return nil
    }
}

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

AInt

BString

CUser?

DVoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different return type than the protocol.

Forgetting to return a value.

The implementation must match the protocol signature, returning an optional User.

3fill in blank

hard

Fix the error in the repository method signature to match the protocol.

iOS Swift

func fetchUser(id: Int) -> [1] {
    // code
}

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

AUser?

BString

CVoid

DUser

Attempts:

3 left

💡 Hint

Common Mistakes

Returning non-optional User which causes mismatch.

Using unrelated types like String or Void.

The method must return an optional User (User?) to match the protocol and handle missing users.

4fill in blank

hard

Fill both blanks to create a repository method that fetches a user by id and returns a default if not found.

iOS Swift

func fetchUserOrDefault(id: Int) -> [1] {
    return fetchUser(id: id) [2] User(name: "Guest")
}

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

AUser

B??

C!

D->

Attempts:

3 left

💡 Hint

Common Mistakes

Using ! which force unwraps and can crash.

Using -> in place of ?? which is invalid.

The method returns a User and uses the nil-coalescing operator ?? to provide a default User if fetchUser returns nil.

5fill in blank

hard

Fill all three blanks to define a repository protocol with a save method and implement it in a class.

iOS Swift

protocol UserRepository {
    func save(user: [1]) -> [2]
}

class UserRepositoryImpl: UserRepository {
    func save(user: [3]) -> Bool {
        // Save logic
        return true
    }
}

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

AUser

BBool

CUser?

DVoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using optional User? as parameter which is not required here.

Returning Void instead of Bool.

Mismatching parameter types between protocol and class.

The protocol defines a save method that takes a User and returns a Bool indicating success. The class implements the same signature.

Practice

1.

What is the main purpose of the Repository pattern in iOS Swift development?

easy

A. To separate data access logic from the rest of the app

B. To handle UI animations smoothly

C. To manage app navigation between screens

D. To store user interface layout information

Solution

1. Step 1: Understand the role of Repository pattern

   The Repository pattern is designed to isolate data access logic from business logic in an app.

2. Step 2: Identify the correct purpose

   Separating data access makes the app easier to maintain and test, which matches To separate data access logic from the rest of the app.

3. Final Answer:

   To separate data access logic from the rest of the app -> Option A

4. Quick Check:

   Repository pattern = separate data access [OK]

Hint: Repository = data access separation [OK]

Common Mistakes:

• Confusing Repository with UI or navigation roles
• Thinking Repository manages animations
• Assuming Repository stores UI layout

2.

Which of the following is the correct way to declare a repository protocol in Swift?

?

easy

A. struct UserRepository { func fetchUsers() -> [User] }

B. class UserRepository { func fetchUsers() -> [User] }

C. enum UserRepository { func fetchUsers() -> [User] }

D. protocol UserRepository { func fetchUsers() -> [User] }

Solution

1. Step 1: Identify correct Swift syntax for protocols

   Protocols in Swift are declared with the keyword protocol followed by method signatures without bodies.

2. Step 2: Match the correct declaration

   protocol UserRepository { func fetchUsers() -> [User] } correctly declares a protocol with a method signature. Other options use class, struct, or enum which are not protocols.

3. Final Answer:

   protocol UserRepository { func fetchUsers() -> [User] } -> Option D

4. Quick Check:

   Protocol declaration uses protocol keyword [OK]

Hint: Protocols start with 'protocol' keyword [OK]

Common Mistakes:

• Using class or struct instead of protocol for interface
• Adding method bodies inside protocol
• Using enum incorrectly for repository

3.

Given the following code snippet, what will be printed?

protocol UserRepository {
  func fetchUsers() -> [String]
}

class MockUserRepository: UserRepository {
  func fetchUsers() -> [String] {
    return ["Alice", "Bob"]
  }
}

let repo: UserRepository = MockUserRepository()
print(repo.fetchUsers())

medium

A. []

B. ["Alice", "Bob"]

C. nil

D. Compilation error

Solution

1. Step 1: Understand protocol conformance and method implementation

   The class MockUserRepository conforms to UserRepository and implements fetchUsers() returning ["Alice", "Bob"].

2. Step 2: Analyze the print statement

   The variable repo is typed as UserRepository but holds an instance of MockUserRepository. Calling fetchUsers() returns ["Alice", "Bob"], which is printed.

3. Final Answer:

   ["Alice", "Bob"] -> Option B

4. Quick Check:

   Protocol method returns mock data [OK]

Hint: Protocol variable calls concrete implementation [OK]

Common Mistakes:

• Expecting empty array instead of returned data
• Thinking protocol variable can't call methods
• Assuming compilation error due to protocol

4.

Identify the error in this repository implementation:

protocol UserRepository {
  func fetchUsers() -> [String]
}

class UserRepo: UserRepository {
  func fetchUsers() {
    return ["Alice", "Bob"]
  }
}

medium

A. Protocol method has wrong name

B. Method does not return a value

C. Missing return type in method signature

D. Class does not conform to protocol

Solution

1. Step 1: Compare protocol and class method signatures

   The protocol method fetchUsers() returns [String]. The class method lacks the return type in its signature.

2. Step 2: Identify the mismatch causing error

   Because the class method signature does not match the protocol, it causes a compilation error. The method must declare the return type.

3. Final Answer:

   Missing return type in method signature -> Option C

4. Quick Check:

   Method signatures must match protocol [OK]

Hint: Method signature must match protocol exactly [OK]

Common Mistakes:

• Forgetting to add return type in implementation
• Assuming method name mismatch
• Thinking protocol conformance is automatic

5.

You want to switch your data source from a local database to a remote API without changing your app's business logic. How does the Repository pattern help you achieve this?

hard

A. By defining a repository interface and implementing separate classes for each data source

B. By embedding API calls directly in the UI code

C. By storing all data in global variables accessible everywhere

D. By using a single class that mixes local and remote data fetching

Solution

1. Step 1: Understand the role of repository interface

   The Repository pattern uses an interface (protocol) to abstract data access methods.

2. Step 2: Implement separate classes for each data source

   You create one class for local database access and another for remote API, both conforming to the same interface. This allows switching without changing business logic.

3. Final Answer:

   By defining a repository interface and implementing separate classes for each data source -> Option A

4. Quick Check:

   Interface + multiple implementations = easy data source switch [OK]

Hint: Use interface + multiple classes for data sources [OK]

Common Mistakes:

• Mixing data fetching code in UI layer
• Using global variables for data access
• Combining local and remote logic in one class