Generic — l’essenza dei tipi generici e i parametri T

Cos’è Generic in Swift?

Generic (tipo generico) — è una costruzione sintattica di Swift che consente di scrivere codice flessibile e riutilizzabile con parametrizzazione dei tipi. Invece di un tipo concreto, viene scritto un segnaposto tra parentesi angolari — di solito , ma è possibile utilizzare qualsiasi nome. I generics sono alla base di SwiftUI (View, some View), della libreria standard (Array, Optional) e di Combine.

Perché servono i generics

Senza generics, si dovrebbero scrivere funzioni separate per ogni tipo: swapInts, swapStrings, swapDates. Una funzione generica swap sostituisce tutte e tre le varianti con una singola dichiarazione. Questo riduce la duplicazione, migliora la leggibilità e riduce la probabilità di errori durante la copia del codice.

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10
var y = 20
swapValues(&x, &y)

Il compilatore Swift genera codice specializzato per ogni utilizzo concreto di un generico. Ciò significa che la funzione generica swapValues non ha overhead rispetto a una funzione scritta a mano per Int. Swift non usa l’eliminazione dei tipi come Java — i generics esistono sia in fase di compilazione che di esecuzione (sebbene l’ottimizzazione possa specializzarli).

Funzioni Generiche con Parametro T

Funzioni generiche sono funzioni che accettano uno o più parametri di tipo. I parametri di tipo vengono specificati dopo il nome della funzione tra parentesi angolari: . Possono essere utilizzati nella firma: tipo dell’argomento, tipo restituito e all’interno del corpo della funzione.

Parametri di Tipo Multipli

Una funzione può avere multipli parametri generici. Ad esempio, la funzione findKey accetta un dizionario con chiavi K e valori V. Ogni parametro di tipo è univoco e può essere utilizzato nei vincoli.

func findKey<K: Hashable, V>(
    for value: V,
    in dictionary: [K: V]
) -> K? where V: Equatable {
    for (key, dictValue) in dictionary {
        if dictValue == value {
            return key
        }
    }
    return nil
}

I vincoli K: Hashable e where V: Equatable garantiscono che findKey possa essere chiamata solo con un dizionario le cui chiavi siano hashable e i valori equatable. Tali vincoli non sono burocrazia ma una necessità: senza Hashable non è possibile indicizzare una ricerca per chiave, senza Equatable non è possibile confrontare value con dictValue.

Vincoli di Tipo con where

where — è una parola chiave di Swift che impone vincoli aggiuntivi ai parametri generici. A differenza della semplice specifica di un protocollo tra parentesi angolari (), where consente di esprimere condizioni più complesse: conformità a più protocolli, relazioni tra parametri di tipo e raffinamento degli associated types.

Sintassi di where

La clausola where viene scritta dopo la firma della funzione o del tipo, prima della parentesi graffa aperta. In where è possibile specificare che T: Comparable & Hashable (conforme a due protocolli simultaneamente), o che T.U == Int (concretizzare un associated type).

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
}

extension Container where Item: Comparable {
    func isSorted() -> Bool {
        // Implementation available only if Item: Comparable
        return true
    }
}

L’estensione con where aggiunge metodi solo per quei tipi che soddisfano la condizione. Container otterrà il metodo isSorted, mentre Container no, perché Any non è Comparable. Questo è un potente meccanismo di funzionalità condizionale.

Associated Types nei Protocolli

Associated Types (tipi associati) — sono un modo per rendere un protocollo generico senza specificare un tipo concreto in fase di dichiarazione. Invece di , il protocollo dichiara un associatedtype, che viene concretizzato nell’implementazione. Ciò è particolarmente importante per le collezioni: il protocollo Sequence non sa quali elementi conterrà la sequenza.

Collegamento degli Associated Types con where

Usando where è possibile stabilire relazioni tra gli associated types di diversi protocolli. Ad esempio, si può richiedere che l’Item di un protocollo corrisponda a Iterator.Element di un altro. Ciò garantisce la compatibilità dei tipi a livello di compilatore.

protocol StackProtocol {
    associatedtype Element
    mutating func push(_ item: Element)
    mutating func pop() -> Element?
}

struct IntStack: StackProtocol {
    typealias Element = Int
    private var items: [Int] = []
    
    mutating func push(_ item: Int) { items.append(item) }
    mutating func pop() -> Int? { items.popLast() }
}

IntStack concretizza Element come Int usando typealias. Il compilatore verifica che tutti i requisiti del protocollo siano soddisfatti con questo tipo. Senza associated types, si dovrebbe scrivere StackProtocol con un protocollo generico, ma Swift usa gli associated types per coerenza con i bridge Objective-C e una migliore leggibilità.

Generic in Estensioni e Subscript

Estensioni generiche consentono di aggiungere metodi a un tipo generico con vincoli aggiuntivi. Questo è il pattern di “conformità condizionale”, in cui un tipo ottiene funzionalità solo in determinate condizioni. Anche i subscript possono essere generici.

Subscript Generico

Un subscript può essere generico: accetta parametri generici tra parentesi angolari. Ciò è utile per l’accesso sicuro alle collezioni con indici arbitrari, dove l’indice può essere di diversi tipi.

extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

extension Array {
    subscript<Indices: Sequence>(indices: Indices) -> [Element]
        where Indices.Element == Int {
        return indices.map { self[$0] }
    }
}

Questa costruzione fornisce una potente composizione: il metodo sum appare solo sugli array numerici, e il subscript con indici arbitrari funziona con qualsiasi sequenza di indici interi. Il compilatore gestisce la visibilità di questi membri in base alle condizioni where.

Errori Comuni con i Generici

Errori nell’uso dei generici sono spesso legati a vincoli errati o al tentativo di usare generici dove serve un tipo concreto. Esaminiamo tre scenari comuni affrontati dagli sviluppatori.

Parametrizzazione Eccessiva

Aggiungere parametri generici dove un tipo concreto è sufficiente è un anti-pattern. Se una funzione lavora sempre con String, non è necessario renderla . Ciò complica il codice senza vantaggi. I generici sono giustificati quando il tipo varia effettivamente, non per una “flessibilità futura” astratta.

Mancanza di Vincolo where

Chiamare un metodo su un parametro generico senza specificare che il metodo esiste è un errore. non può chiamare .count se non viene specificato che T: Collection. Aggiungi sempre vincoli ai parametri di tipo, altrimenti il compilatore rifiuterà il codice.

// ❌ Error: value has no count method
func countElements<T>(value: T) -> Int { value.count }

// ✅ Works: T: Collection guarantees count exists
func countElements<T: Collection>(value: T) -> Int { value.count }

L’errore è chiaro: il generico può essere qualsiasi tipo, e il compilatore non sa se ha count. Il vincolo Collection risolve il problema. Allo stesso modo per Equatable, Hashable, Numeric — specifica sempre il protocollo se prevedi di chiamare metodi o operatori sul parametro generico.