Typealias — o que é, sintaxe e uso em Kotlin

O que é typealias?

Typealias (alias de tipo) é uma declaração que introduz um nome alternativo para um tipo existente. Sintaxe: typealias NovoNome = TipoExistente. Após a declaração, NovoNome pode ser usado onde TipoExistente é esperado — o compilador os trata como o mesmo tipo. No nível do bytecode, typealias não deixa vestígios: todas as informações do alias são apagadas em tempo de compilação.

O principal propósito do typealias é melhorar a legibilidade do código. Em vez de uma assinatura verbosa fun process(callback: (Result) -> Unit), você pode escrever typealias Callback = (Result) -> Unit e usar Callback como tipo de parâmetro. Isso é especialmente útil quando o mesmo tipo funcional se repete em vários lugares do código: o alias serve como um ponto único de definição e documenta o propósito do tipo.

Typealias não cria um novo tipo — é apenas um sinônimo. Variáveis do tipo Callback e (Result) -> Unit são totalmente intercambiáveis. O compilador não produzirá um erro se uma lambda for passada diretamente para uma função que espera Callback. Isso distingue typealias de inline class (value class), que cria um novo tipo wrapper com verificação em tempo de compilação. Typealias é renomear, não encapsular.

Typealias para tipos funcionais

O caso de uso mais comum para typealias em Kotlin são os tipos funcionais. Assinaturas longas como (Int, String) -> Boolean ou (List) -> Result dificultam a leitura do código. Typealias as transforma em nomes curtos e significativos que documentam o propósito da função: typealias Validator = (String) -> Boolean especifica que este é um validador de strings.

// Without typealias
fun findUsers(
    filter: (List<User>) -> List<User>
): List<User>

// With typealias
typealias UserFilter = (List<User>) -> List<User>

fun findUsers(filter: UserFilter): List<User>

// Usage in class
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

No exemplo, o typealias UserFilter oculta o tipo funcional complexo (List) -> List atrás de um nome curto. A assinatura de findUsers se torna legível: "aceita UserFilter, retorna List". O typealias OnClickListener faz o código se assemelhar a uma declaração de interface, mas sem a sobrecarga de criar uma interface ou classe abstrata separada. Enquanto isso, lambdas e funções anônimas continuam funcionando normalmente — typealias não requer alterações no código chamador.

Typealias com genéricos

Typealias suporta parâmetros genéricos, tornando-o ainda mais flexível. Você pode definir typealias Mapper = (T) -> R e usá-lo com qualquer tipo. O compilador substitui tipos específicos pelos parâmetros a cada uso do alias, preservando a segurança total de tipos.

// Generic typealias
typealias Mapper<T, R> = (T) -> R
typealias Provider<T> = () -> T
typealias ListTransformer<T> = (List<T>) -> List<T>

fun processNumbers(mapper: Mapper<Int, String>) {
    // mapper type is (Int) -> String
}

fun main() {
    val config: Provider<String> = { "default config" }
    val reverse: ListTransformer<Int> = { it.reversed() }
}

Na listagem, Mapper é um alias genérico para qualquer transformação de T para R. Provider é um fornecedor de valor (uma fábrica sem argumentos). ListTransformer é uma função de transformação de lista. Ao chamar processNumbers(mapper: Mapper), o compilador expande o alias para (Int) -> String. Os genéricos tornam typealias uma ferramenta universal adequada para qualquer contexto sem duplicar declarações.

Typealias para nomes aninhados e longos

Classes aninhadas e tipos parametrizados longos são outra área onde typealias simplifica significativamente o código. Se uma classe está profunda em uma hierarquia de aninhamento (Outer.Inner.Nested), referenciá-la pelo nome completo polui o código. Typealias encurta esse acesso e o torna mais legível. Isso é especialmente relevante para classes de bibliotecas de terceiros com nomes longos.

// Alias for nested class
class NetworkResponse {
    class Error(val code: Int, val message: String)
}
typealias NetworkError = NetworkResponse.Error

// Alias for long library type
typealias UserId = Long
typealias JsonMap = Map<String, Any?>

fun process(error: NetworkError) {
    println("${error.code}: ${error.message}")
}

fun parseJson(data: JsonMap): UserId {
    return data["id"] as? Long ?: 0L
}

No exemplo, NetworkError é um alias para a classe aninhada NetworkResponse.Error. Ao importar o typealias, você pode usar NetworkError como um tipo normal sem revelar a hierarquia de aninhamento. JsonMap documenta que o mapa representa um objeto JSON. UserId esclarece o propósito de Long em um contexto específico — o leitor entende imediatamente que é um identificador de usuário, não um número arbitrário. No entanto, typealias não impede passar um Long simples onde UserId é esperado — para isso, uma value class é necessária.

Typealias vs inline class: diferenças

Typealias e inline class (value class) resolvem problemas diferentes, embora ambos introduzam um novo nome para um tipo. Typealias é apenas um sinônimo: uma variável do tipo UserId = Long aceita qualquer Long sem verificação. Inline class envolve um valor em um novo tipo que é verificado em tempo de compilação: não é possível passar um Long simples onde se espera uma inline class UserId sem conversão explícita.

A tabela mostra a diferença entre os dois mecanismos. Typealias é adequado para nomes concisos e documentação de código quando a tipagem estrita não é necessária. Inline class através da palavra-chave value class (anteriormente inline class) é necessária quando é importante distinguir valores semanticamente diferentes do mesmo tipo primitivo. Por exemplo, UserId e OrderId são ambos Long, mas passar um onde o outro é esperado é um erro lógico que a value class previne em tempo de compilação.