Mid-Level iOS Engineer

Approach: Use TaskGroup for concurrent downloads with proper error handling

Key Concepts: Structured concurrency, error propagation, TaskGroup

Implementation:

import UIKit

class ImageDownloader {
    func downloadImages(from urls: [URL]) async throws -> [UIImage] {
        return try await withThrowingTaskGroup(of: (Int, UIImage).self) { group in
            // Add tasks for each URL with index tracking
            for (index, url) in urls.enumerated() {
                group.addTask {
                    let (data, _) = try await URLSession.shared.data(from: url)
                    guard let image = UIImage(data: data) else {
                        throw ImageDownloadError.invalidImageData
                    }
                    return (index, image)
                }
            }
            
            // Collect results maintaining original order
            var results: [UIImage?] = Array(repeating: nil, count: urls.count)
            
            for try await (index, image) in group {
                results[index] = image
            }
            
            // Filter out any nil values (shouldn't happen with proper error handling)
            return results.compactMap { $0 }
        }
    }
    
    // Alternative approach with error collection instead of throwing on first error
    func downloadImagesWithPartialFailure(from urls: [URL]) async -> (images: [UIImage], errors: [Error]) {
        return await withTaskGroup(of: Result<(Int, UIImage), Error>.self) { group in
            for (index, url) in urls.enumerated() {
                group.addTask {
                    do {
                        let (data, _) = try await URLSession.shared.data(from: url)
                        guard let image = UIImage(data: data) else {
                            throw ImageDownloadError.invalidImageData
                        }
                        return .success((index, image))
                    } catch {
                        return .failure(error)
                    }
                }
            }
            
            var images: [UIImage] = []
            var errors: [Error] = []
            
            for await result in group {
                switch result {
                case .success((_, let image)):
                    images.append(image)
                case .failure(let error):
                    errors.append(error)
                }
            }
            
            return (images, errors)
        }
    }
}

enum ImageDownloadError: Error {
    case invalidImageData
}

Key Points to Explain:

• TaskGroup enables structured concurrency with automatic cancellation propagation
• withThrowingTaskGroup stops all tasks on first error, while withTaskGroup allows collecting partial results
• Index tracking preserves the original order of requests
• Proper error handling prevents memory leaks and provides clear failure modes
• Result type enables graceful handling of individual failures without stopping the entire operation