Typealias: cos'è, sintassi e utilizzo

Cos'è Typealias?

Typealias è una dichiarazione in Swift che introduce un nome alternativo per un tipo esistente. Dopo aver dichiarato un typealias, il nuovo nome può essere usato ovunque sia previsto il tipo originale — il compilatore li tratta come identici. Typealias non aggiunge isolamento semantico: un valore di tipo UserID (typealias per String) può essere passato a una funzione che si aspetta String senza errore.

Gli scopi principali di typealias sono abbreviare nomi lunghi, documentare lo scopo di un tipo e astrarre l'implementazione concreta. Ad esempio, typealias JSON = [String: Any] indica esplicitamente che un dizionario viene usato come struttura JSON, e typealias Completion = (Result<Data, Error>) -> Void trasforma una firma di closure complessa in un tipo leggibile.

Secondo Swift.org (2025), typealias è ampiamente usato nella libreria standard. Ad esempio, String è un typealias per String (un Array<Character> specializzato), sebbene nelle versioni moderne di Swift questa implementazione sia nascosta. Void è un typealias per la tupla vuota (), che rende le firme delle funzioni più leggibili.

Usa typealias per documentare la semantica di un tipo, ma ricorda: non protegge dalla mescolanza di diversi concetti dello stesso tipo base. Per una separazione type-safe, usa wrapper (struct wrapper).

Sintassi e ambiti

Typealias si dichiara con la parola chiave typealias, seguita dal nuovo nome, un segno di uguale e il tipo esistente. La forma base:

typealias Name = ExistingType
typealias UserID = Int
typealias JSONDictionary = [String: Any]

L'ambito di un typealias è determinato da dove viene dichiarato:

Typealias all'interno di un tipo (ad esempio, User.ID) è un pattern comune per raggruppare alias correlati. Ciò migliora il namespacing: Order.ID e User.ID sono entrambi Int, ma vengono letti come concetti diversi. L'accesso a un typealias annidato avviene tramite User.ID o tramite notazione puntata se il tipo è noto.

Typealias per tipi closure

Uno degli usi più comuni di typealias è semplificare le firme delle closure. I tipi closure in Swift possono essere ingombranti, specialmente con Optional e parametri generici. Typealias trasforma (Data?, Error?) -> Void in un leggibile FetchResultHandler:

typealias FetchResultHandler = (Data?, Error?) -> Void

func fetchUser(id: Int, completion: FetchResultHandler) {
    // network request
    completion(data, nil)
}

Secondo la Guida di Stile di Ray Wenderlich, typealias per le closure migliora la leggibilità delle firme dei metodi, specialmente nei protocolli di delega e nei pattern di callback. Tuttavia, evita alias eccessivi — se una closure viene usata in un solo punto, può essere dichiarata inline.

La libreria standard di Swift utilizza attivamente questo approccio. Ad esempio, DispatchQueue.WorkItem è un typealias per DispatchWorkItem, sebbene esternamente sembri un tipo separato. Typealias per le closure è uno strumento di leggibilità — non abusarne: 3–5 alias di closure per modulo è un limite ragionevole.

Typealias e parametri generici

Typealias può includere parametri generici, creando versioni specializzate di tipi generici. Ciò è particolarmente utile quando si lavora con Result, Publisher e altri tipi generici della libreria standard e Combine:

typealias FetchResult = Result<Data, Error>
typealias AnyPublisherOfData = AnyPublisher<Data, Error>

func loadData() -> FetchResult {
    // data loading
}

Puoi anche creare typealias con parametri generici personalizzati che vengono inoltrati al tipo originale:

typealias NetworkResult<T> = Result<T, NetworkError>

func fetchUser() -> NetworkResult<User> {
    // ...
}

Una regola importante: typealias non può aggiungere nuove restrizioni generiche (clausole where) — si limita a inoltrare parametri al tipo originale. Se sono necessarie restrizioni aggiuntive, crea una struct o una classe generica. Secondo Swift by Sundell (2024), typealias con i generici è un modo ideale per abbreviare firme ripetitive in progetti che usano intensamente Combine, Result e async/await.

Associatedtype nei protocolli

Associatedtype è un typealias dichiarato all'interno di un protocollo che definisce un tipo associato. A differenza di un typealias normale, associatedtype non è legato a un tipo specifico al momento della dichiarazione — viene specificato da ogni tipo che adotta il protocollo:

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

struct IntBox: Container {
    typealias Item = Int
    // implementation
}

struct StringBox: Container {
    typealias Item = String
    // implementation
}

Associatedtype conferisce ai protocolli la flessibilità dei tipi generici senza specificare un tipo concreto nel punto di dichiarazione. Questa è la base di molti pattern Swift: Collection (Element), IteratorProtocol (Element), Identifiable (ID). Il compilatore può inferire associatedtype automaticamente dall'implementazione, quindi un esplicito typealias Item = Int viene spesso omesso — Swift inferisce Item come Int dal parametro del metodo append.

Secondo Swift Evolution SE-0195 (2022), sono stati introdotti i tipi di risultato opachi (some Container) per lavorare con protocolli che contengono associatedtype — ciò ha risolto il problema PAT (protocollo con tipi associati), che impediva di usare tali protocolli come tipi di variabile.

Typealias vs wrapper di tipo

La differenza chiave: typealias è solo un altro nome per un tipo esistente, mentre un wrapper è un nuovo tipo, semanticamente isolato dall'originale. Se dichiari typealias UserID = Int, allora UserID e Int sono intercambiabili — una funzione che si aspetta Int accetterà UserID senza errore.

Un wrapper viene creato tramite struct e fornisce vera sicurezza dei tipi:

struct UserID: RawRepresentable {
    let rawValue: Int
}

struct OrderID: RawRepresentable {
    let rawValue: Int
}

// Compilation error: cannot pass OrderID where UserID is expected

Secondo Point-Free (2025), i wrapper sono preferibili quando diversi concetti sono rappresentati dallo stesso tipo base (UserID vs OrderID). Typealias è giustificato quando l'obiettivo è la leggibilità senza isolamento: abbreviare nomi lunghi, documentare la semantica, astrarre l'implementazione tramite associatedtype. Scegli typealias per la comodità di lettura, wrapper per la sicurezza dei tipi.