Typealias: o que é, sintaxe e uso

O que é Typealias?

Typealias é uma declaração em Swift que introduz um nome alternativo para um tipo existente. Após declarar um typealias, o novo nome pode ser usado onde o tipo original é esperado — o compilador os trata como idênticos. Typealias não adiciona isolamento semântico: um valor do tipo UserID (typealias para String) pode ser passado para uma função que espera String sem erro.

Os principais propósitos do typealias são encurtar nomes longos, documentar o propósito de um tipo e abstrair a implementação concreta. Por exemplo, typealias JSON = [String: Any] indica explicitamente que um dicionário é usado como estrutura JSON, e typealias Completion = (Result<Data, Error>) -> Void transforma uma assinatura de closure complexa em um tipo legível.

De acordo com Swift.org (2025), typealias é amplamente usado na biblioteca padrão. Por exemplo, String é um typealias para String (um Array<Character> especializado), embora nas versões modernas do Swift esta implementação esteja oculta. Void é um typealias para a tupla vazia (), o que torna as assinaturas de função mais legíveis.

Use typealias para documentar a semântica de um tipo, mas lembre-se: ele não protege contra a mistura de diferentes conceitos do mesmo tipo base. Para separação com segurança de tipos, use wrappers (struct wrapper).

Sintaxe e escopos

Typealias é declarado com a palavra-chave typealias, seguida pelo novo nome, um sinal de igual e o tipo existente. A forma básica:

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

O escopo de um typealias é determinado por onde ele é declarado:

Typealias dentro de um tipo (por exemplo, User.ID) é um padrão comum para agrupar apelidos relacionados. Isso melhora o namespacing: Order.ID e User.ID são ambos Int, mas lidos como conceitos diferentes. O acesso a um typealias aninhado é feito através de User.ID ou por notação de ponto se o tipo for conhecido.

Typealias para tipos closure

Um dos usos mais comuns de typealias é simplificar assinaturas de closure. Tipos closure em Swift podem ser complicados, especialmente com Optional e parâmetros genéricos. Typealias transforma (Data?, Error?) -> Void em um legível FetchResultHandler:

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

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

De acordo com o Ray Wenderlich Style Guide, typealias para closures melhora a legibilidade das assinaturas de métodos, especialmente em protocolos de delegação e padrões de callback. No entanto, evite apelidos em excesso — se um closure é usado em um único lugar, pode ser declarado inline.

A biblioteca padrão do Swift usa ativamente esta abordagem. Por exemplo, DispatchQueue.WorkItem é um typealias para DispatchWorkItem, embora externamente pareça um tipo separado. Typealias para closures é uma ferramenta de legibilidade — não abuse: 3–5 apelidos de closure por módulo é um limite razoável.

Typealias e parâmetros genéricos

Typealias pode incluir parâmetros genéricos, criando versões especializadas de tipos genéricos. Isso é especialmente útil ao trabalhar com Result, Publisher e outros tipos genéricos da biblioteca padrão e Combine:

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

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

Você também pode criar typealias com parâmetros genéricos personalizados que são encaminhados para o tipo original:

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

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

Uma regra importante: typealias não pode adicionar novas restrições genéricas (where clauses) — ele apenas encaminha parâmetros para o tipo original. Se restrições adicionais forem necessárias, crie uma struct ou classe genérica. De acordo com Swift by Sundell (2024), typealias com genéricos é uma forma ideal de encurtar assinaturas repetitivas em projetos que usam Combine, Result e async/await intensivamente.

Associatedtype em protocolos

Associatedtype é um typealias declarado dentro de um protocolo que define um tipo associado. Ao contrário de um typealias comum, associatedtype não está vinculado a um tipo específico no momento da declaração — é especificado por cada tipo que adota o 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 dá aos protocolos a flexibilidade dos tipos genéricos sem especificar um tipo concreto no local da declaração. Esta é a base de muitos padrões Swift: Collection (Element), IteratorProtocol (Element), Identifiable (ID). O compilador pode inferir associatedtype automaticamente a partir da implementação, portanto um typealias Item = Int explícito é frequentemente omitido — Swift infere Item como Int a partir do parâmetro do método append.

De acordo com Swift Evolution SE-0195 (2022), tipos de resultado opacos (some Container) foram introduzidos para trabalhar com protocolos que contêm associatedtype — isso resolveu o problema PAT (protocolo com tipos associados), que impedia o uso desses protocolos como tipos de variável.

Typealias vs wrapper de tipo

A diferença principal: typealias é apenas outro nome para um tipo existente, enquanto um wrapper é um novo tipo, semanticamente isolado do original. Se você declarar typealias UserID = Int, então UserID e Int são intercambiáveis — uma função que espera Int aceitará UserID sem erro.

Um wrapper é criado através de struct e fornece verdadeira segurança de tipos:

struct UserID: RawRepresentable {
    let rawValue: Int
}

struct OrderID: RawRepresentable {
    let rawValue: Int
}

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

De acordo com Point-Free (2025), wrappers são preferíveis quando diferentes conceitos são representados pelo mesmo tipo base (UserID vs OrderID). Typealias é justificado quando o objetivo é legibilidade sem isolamento: encurtar nomes longos, documentar semântica, abstrair implementação através de associatedtype. Escolha typealias para conveniência de leitura, wrapper para segurança de tipos.