JohnSundell

class ModelLoader<T: Unboxable & Requestable> {
    func load(completionHandler: (Result<T>) -> Void) {
        networkService.loadData(from: T.requestURL) { data in
            do {
                try completionHandler(.success(unbox(data: data)))
            } catch {
                let error = ModelLoadingError.unboxingFailed(error)
                completionHandler(.error(error))
            }
        }

JohnSundell

protocol ModelLoading {
    associatedtype Model
    
    func load(completionHandler: (Result<Model>) -> Void)
}

JohnSundell

class ViewController: UIViewController {
    init(modelLoader: ModelLoading) {
        ...
    }
}

JohnSundell

class ViewController: UIViewController {
    init<T: ModelLoading>(modelLoader: T) where T.Model == MyModel {
        ...
    }
}

JohnSundell

class AnyModelLoader<T>: ModelLoading {
    typealias CompletionHandler = (Result<T>) -> Void
    
    private let loadingClosure: (CompletionHandler) -> Void
    
    init<L: ModelLoading>(loader: L) where L.Model == T {
        loadingClosure = loader.load
    }
    
    func load(completionHandler: CompletionHandler) {

JohnSundell

class ViewController: UIViewController {
    private let modelLoader: AnyModelLoader<MyModel>
  
    init<T: ModelLoading>(modelLoader: T) where T.Model == MyModel {
        self.modelLoader = AnyModelLoader(loader: modelLoader)
        super.init(nibName: nil, bundle: nil)
    }
}

JohnSundell

class ViewController: UIViewController {
    private let loadModel: ((Result<MyModel>) -> Void) -> Void
    
    init<T: ModelLoading>(modelLoader: T) where T.Model == MyModel {
        loadModel = modelLoader.load
        super.init(nibName: nil, bundle: nil)
    }
}

JohnSundell

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
   
    loadModel { result in
        switch result {
        case .success(let model):
            render(model)
        case .error(let error):
            render(error)
        }

JohnSundell

class ModelLoader {
    func loadAllModels() -> [Model] { … }
}

JohnSundell

struct ModelSequence: Sequence {
    func makeIterator() -> ModelIterator {
        return ModelIterator()
    }
}