Qual gestore di completamento hai scritto?

Esempio di gestore di completamento per una richiesta di rete con possibili errori:

// Definiamo un tipo per il risultato della richiesta (successo o errore)
typealias RequestResult<T: Codable> = Result<T, Error>

// Funzione per eseguire una richiesta di rete
func performRequest<T: Codable>(url: URL, completion: @escaping (RequestResult<T>) -> Void) {
    // In questo blocco, di solito, si effettua la chiamata a URLSession.shared.dataTask
    // con gestione della risposta, decodifica JSON e errori.

    // Esempio di gestione (supponiamo che si riceva una risposta di successo e dati)
    let sampleData = Data() // Qui dovrebbero esserci dati reali
    let decoder = JSONDecoder()

    do {
        let decodedData = try decoder.decode(T.self, from: sampleData)
        completion(.success(decodedData)) // Chiamiamo la completion con successo
    } catch {
        completion(.failure(error)) // Chiamiamo la completion con errore se la decodifica fallisce
    }

    // Esempio di gestione di errore di rete o server
    // let networkError = URLError(.notConnectedToInternet)
    // completion(.failure(networkError)) // Chiamiamo la completion con errore di rete
}

// Esempio di utilizzo:
struct SampleData: Codable {
    let id: Int
    let name: String
}

let apiUrl = URL(string: "https://api.example.com/data")!

performRequest(url: apiUrl) { result in
    switch result {
    case .success(let data):
        print("Success! Data received: \(data)")
    case .failure(let error):
        print("Request error: \(error.localizedDescription)")
    }
}