Typealias: qué es, sintaxis y uso

¿Qué es Typealias?

Typealias es una declaración en Swift que introduce un nombre alternativo para un tipo existente. Después de declarar un typealias, el nuevo nombre se puede usar donde se espere el tipo original — el compilador los trata como idénticos. Typealias no añade aislamiento semántico: un valor de tipo UserID (typealias para String) se puede pasar a una función que espera String sin error.

Los propósitos principales de typealias son acortar nombres largos, documentar el propósito de un tipo y abstraer la implementación concreta. Por ejemplo, typealias JSON = [String: Any] indica explícitamente que un diccionario se usa como estructura JSON, y typealias Completion = (Result<Data, Error>) -> Void convierte una firma de closure compleja en un tipo legible.

Según Swift.org (2025), typealias se usa ampliamente en la biblioteca estándar. Por ejemplo, String es un typealias para String (un Array<Character> especializado), aunque en versiones modernas de Swift esta implementación está oculta. Void es un typealias para la tupla vacía (), lo que hace que las firmas de funciones sean más legibles.

Usa typealias para documentar la semántica de un tipo, pero recuerda: no protege contra la mezcla de diferentes conceptos del mismo tipo base. Para una separación con seguridad de tipos, usa wrappers (struct wrapper).

Sintaxis y ámbitos

Typealias se declara con la palabra clave typealias, seguida del nuevo nombre, un signo igual y el tipo existente. La forma básica:

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

El ámbito de un typealias se determina por el lugar donde se declara:

Typealias dentro de un tipo (por ejemplo, User.ID) es un patrón común para agrupar alias relacionados. Esto mejora el namespacing: Order.ID y User.ID son ambos Int, pero se leen como conceptos diferentes. El acceso a un typealias anidado se realiza a través de User.ID o mediante notación de punto si se conoce el tipo.

Typealias para tipos closure

Uno de los usos más frecuentes de typealias es simplificar firmas de closure. Los tipos closure en Swift pueden ser engorrosos, especialmente con Optional y parámetros genéricos. Typealias convierte (Data?, Error?) -> Void en un legible FetchResultHandler:

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

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

Según la Guía de Estilo de Ray Wenderlich, typealias para closures mejora la legibilidad de las firmas de métodos, especialmente en protocolos de delegación y patrones de callback. Sin embargo, evita el exceso de alias — si un closure se usa en un solo lugar, se puede declarar inline.

La biblioteca estándar de Swift usa activamente este enfoque. Por ejemplo, DispatchQueue.WorkItem es un typealias para DispatchWorkItem, aunque desde fuera parece un tipo separado. Typealias para closures es una herramienta de legibilidad — no abuses: 3–5 alias de closure por módulo es un límite razonable.

Typealias y parámetros genéricos

Typealias puede incluir parámetros genéricos, creando versiones especializadas de tipos genéricos. Esto es especialmente útil al trabajar con Result, Publisher y otros tipos genéricos de la biblioteca estándar y Combine:

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

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

También se pueden crear typealias con parámetros genéricos personalizados que se redirigen al tipo original:

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

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

Una regla importante: typealias no puede añadir nuevas restricciones genéricas (where clauses) — solo redirige parámetros al tipo original. Si se necesitan restricciones adicionales, crea una estructura o clase genérica. Según Swift by Sundell (2024), typealias con genéricos es una forma ideal de acortar firmas repetitivas en proyectos que usan Combine, Result y async/await intensivamente.

Associatedtype en protocolos

Associatedtype es un typealias declarado dentro de un protocolo que define un tipo asociado. A diferencia de un typealias normal, associatedtype no está vinculado a un tipo específico en el momento de la declaración — lo concreta cada tipo que adopta el protocolo:

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 da a los protocolos la flexibilidad de los tipos genéricos sin especificar un tipo concreto en el lugar de la declaración. Esta es la base de muchos patrones de Swift: Collection (Element), IteratorProtocol (Element), Identifiable (ID). El compilador puede inferir associatedtype automáticamente a partir de la implementación, por lo que un typealias Item = Int explícito a menudo se omite — Swift infiere Item como Int a partir del parámetro del método append.

Según Swift Evolution SE-0195 (2022), se introdujeron los tipos de resultado opacos (some Container) para trabajar con protocolos que contienen associatedtype — esto resolvió el problema PAT (protocolo con tipos asociados), que impedía usar estos protocolos como tipos de variable.

Typealias vs wrapper de tipo

La diferencia clave: typealias es solo otro nombre para un tipo existente, mientras que un wrapper es un tipo nuevo, semánticamente aislado del original. Si declaras typealias UserID = Int, entonces UserID y Int son intercambiables — una función que espera Int aceptará UserID sin error.

Un wrapper se crea mediante struct y proporciona verdadera seguridad de tipos:

struct UserID: RawRepresentable {
    let rawValue: Int
}

struct OrderID: RawRepresentable {
    let rawValue: Int
}

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

Según Point-Free (2025), los wrappers son preferibles cuando diferentes conceptos están representados por el mismo tipo base (UserID vs OrderID). Typealias está justificado cuando el objetivo es la legibilidad sin aislamiento: acortar nombres largos, documentar semántica, abstraer implementación mediante associatedtype. Elige typealias para conveniencia de lectura, wrapper para seguridad de tipos.