10 Swift Combine Interview Questions and Answers

Swift Combine is a powerful framework introduced by Apple for handling asynchronous events in a declarative manner. It simplifies the process of managing data streams and event-driven programming, making it an essential tool for modern iOS development. By leveraging Combine, developers can write cleaner, more maintainable code that efficiently handles complex data flows and user interactions.

This article offers a curated selection of interview questions designed to test your understanding and proficiency with Swift Combine. Reviewing these questions will help you solidify your knowledge, demonstrate your expertise, and confidently tackle technical interviews focused on iOS development.

Swift Combine Interview Questions and Answers

1. Write a simple example of a Publisher that emits a sequence of integers from 1 to 5 and a Subscriber that prints each received value.

In Swift Combine, a Publisher emits a sequence of values over time, while a Subscriber receives and processes these values. Below is a simple example of a Publisher that emits integers from 1 to 5 and a Subscriber that prints each received value.

import Combine

let publisher = [1, 2, 3, 4, 5].publisher

let subscriber = Subscribers.Sink<Int, Never>(
    receiveCompletion: { completion in
        print("Completed with: \(completion)")
    },
    receiveValue: { value in
        print("Received value: \(value)")
    }
)

publisher.subscribe(subscriber)

2. Demonstrate how to use a PassthroughSubject to emit values and have a subscriber print those values.

In Swift’s Combine framework, a PassthroughSubject is used to emit values to its subscribers without retaining them. It simply passes them through as they are received.

Here is an example demonstrating how to use a PassthroughSubject to emit values and have a subscriber print those values:

import Combine

let subject = PassthroughSubject<String, Never>()

let subscriber = subject.sink { value in
    print("Received value: \(value)")
}

subject.send("Hello")
subject.send("World")

3. Describe the role of operators in Combine and provide an example of how to use the map operator.

Operators in Combine manipulate and transform data emitted by publishers. They handle asynchronous data streams declaratively. The map operator transforms values emitted by a publisher into a different form.

Here is an example of using the map operator:

import Combine

let numbers = [1, 2, 3, 4, 5]
let publisher = numbers.publisher

let subscription = publisher
    .map { $0 * 2 }
    .sink { value in
        print(value)
    }

4. Write a Combine pipeline that filters out even numbers from a sequence of integers and then maps the remaining numbers to their squares.

To filter out even numbers from a sequence of integers and then map the remaining numbers to their squares, use Combine’s filter and map operators. Here is an example:

import Combine

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let publisher = numbers.publisher

let cancellable = publisher
    .filter { $0 % 2 != 0 }
    .map { $0 * $0 }
    .sink { print($0) }

5. Implement a Combine pipeline that retries a network request up to three times before failing.

To implement a Combine pipeline that retries a network request up to three times before failing, use the retry operator. This operator attempts to re-subscribe to the upstream publisher a specified number of times if it encounters an error.

Here is an example:

import Combine
import Foundation

struct NetworkError: Error {}

func fetchData(url: URL) -> AnyPublisher<Data, Error> {
    URLSession.shared.dataTaskPublisher(for: url)
        .map(\.data)
        .mapError { _ in NetworkError() }
        .eraseToAnyPublisher()
}

let url = URL(string: "https://example.com")!
let cancellable = fetchData(url: url)
    .retry(3)
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Request completed successfully.")
        case .failure(let error):
            print("Request failed with error: \(error)")
        }
    }, receiveValue: { data in
        print("Received data: \(data)")
    })

6. Write a Combine pipeline that debounces user input from a text field, ensuring that the search query is only sent after the user has stopped typing for 0.5 seconds.

Debouncing limits the rate at which a function is executed. In user input, it ensures a search query is only sent after the user stops typing for a specified duration, reducing unnecessary requests.

In Swift, use the debounce operator in a Combine pipeline to debounce user input from a text field.

import Combine
import UIKit

class ViewController: UIViewController {
    @IBOutlet weak var textField: UITextField!
    
    private var cancellable: AnyCancellable?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        cancellable = NotificationCenter.default.publisher(for: UITextField.textDidChangeNotification, object: textField)
            .compactMap { ($0.object as? UITextField)?.text }
            .debounce(for: .milliseconds(500), scheduler: RunLoop.main)
            .sink { searchText in
                self.performSearch(query: searchText)
            }
    }
    
    private func performSearch(query: String) {
        print("Searching for: \(query)")
    }
}

7. Create a custom Combine operator that logs each value passing through the pipeline.

In Swift Combine, custom operators can extend the functionality of existing publishers. To create a custom operator that logs each value passing through the pipeline, use the handleEvents operator.

Here is an example:

import Combine

extension Publisher {
    func logValues() -> Publishers.HandleEvents<Self> {
        return handleEvents(receiveOutput: { value in
            print("Received value: \(value)")
        })
    }
}

let _ = [1, 2, 3, 4, 5].publisher
    .logValues()
    .sink(receiveCompletion: { _ in },
          receiveValue: { _ in })

8. Implement a Combine pipeline that merges two publishers and handles errors from either publisher gracefully.

To merge two publishers and handle errors gracefully, use the merge operator along with error handling operators like catch and replaceError.

import Combine

let publisher1 = PassthroughSubject<Int, Error>()
let publisher2 = PassthroughSubject<Int, Error>()

let mergedPublisher = Publishers.Merge(publisher1, publisher2)
    .catch { _ in Just(-1) }
    .eraseToAnyPublisher()

let cancellable = mergedPublisher.sink(
    receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished")
        case .failure(let error):
            print("Error: \(error)")
        }
    },
    receiveValue: { value in
        print("Received value: \(value)")
    }
)

publisher1.send(1)
publisher2.send(2)
publisher1.send(completion: .failure(NSError(domain: "", code: -1, userInfo: nil)))
publisher2.send(3)
publisher2.send(completion: .finished)

9. Explain how error handling works in Combine pipelines and provide an example.

Error handling in Combine pipelines manages and responds to errors during asynchronous event processing. Combine provides operators like catch and retry to define how the pipeline should react when an error is encountered.

Example:

import Combine

enum MyError: Error {
    case sampleError
}

let subject = PassthroughSubject<Int, MyError>()

let subscription = subject
    .map { value -> Int in
        if value == 3 {
            throw MyError.sampleError
        }
        return value * 2
    }
    .catch { error in
        Just(-1)
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished successfully")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { value in
        print("Received value: \(value)")
    })

subject.send(1)
subject.send(2)
subject.send(3)
subject.send(4)
subject.send(completion: .finished)

10. Explain how to combine multiple publishers in Combine and provide an example.

In Swift’s Combine framework, you can combine multiple publishers to handle multiple data streams simultaneously. This is useful when you need to work with data from different sources and synchronize their outputs. Combine provides several operators to achieve this, such as merge, zip, and combineLatest.

• merge: Combines elements from multiple publishers into a single publisher, emitting values as they arrive from any of the upstream publishers.
• zip: Combines elements from multiple publishers into pairs, emitting a tuple of values only when all publishers have emitted a value.
• combineLatest: Combines the latest values from multiple publishers, emitting a tuple whenever any of the upstream publishers emit a value.

Example:

import Combine

let publisher1 = PassthroughSubject<Int, Never>()
let publisher2 = PassthroughSubject<String, Never>()

let cancellable = Publishers.CombineLatest(publisher1, publisher2)
    .sink { value1, value2 in
        print("Received: \(value1) and \(value2)")
    }

publisher1.send(1)
publisher2.send("A")
publisher1.send(2)
publisher2.send("B")

In this example, Publishers.CombineLatest is used to combine the latest values from publisher1 and publisher2. The sink subscriber receives a tuple of the latest values whenever either publisher emits a new value.