Typealias — ce este, sintaxa și aplicarea în Kotlin

Ce este typealias?

Typealias (alias de tip) — este o declarație care introduce un nume alternativ pentru un tip existent. Sintaxa: typealias NumeNou = TipExistent. După declarație, NumeNou poate fi folosit oriunde este așteptat TipExistent — compilatorul le tratează ca același tip. La nivel de bytecode, typealias nu lasă urme: toate informațiile despre alias sunt șterse în faza de compilare.

Scopul principal al typealias este îmbunătățirea lizibilității codului. În locul unei semnături lungi fun process(callback: (Result) -> Unit) se poate scrie typealias Callback = (Result) -> Unit și folosi Callback ca tip de parametru. Acest lucru este util în special când același tip funcțional se repetă în mai multe locuri din cod: aliasul servește ca punct unic de definiție și documentează scopul tipului.

Typealias nu creează un tip nou — este doar un sinonim. Variabilele de tip Callback și (Result) -> Unit sunt complet interschimbabile. Compilatorul nu va da eroare dacă într-o funcție care așteaptă Callback este transmisă direct o lambda. Aceasta deosebește typealias de inline class (value class), care creează un nou tip-învelitor cu verificare la compilare. Typealias este o redenumire, nu o învelire.

Typealias pentru tipuri funcționale

Cel mai frecvent scenariu de utilizare a typealias în Kotlin sunt tipurile funcționale. Semnăturile lungi precum (Int, String) -> Boolean sau (List) -> Result fac codul greu de citit. Typealias le transformă în nume scurte și semnificative care documentează scopul funcției: typealias Validator = (String) -> Boolean specifică că este un validator de șiruri.

// Fără typealias
fun findUsers(
    filter: (List<User>) -> List<User>
): List<User>

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

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

// Utilizare în clasă
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

În exemplu, typealias UserFilter ascunde tipul funcțional complex (List) -> List în spatele unui nume scurt. Semnătura findUsers devine lizibilă: «primește UserFilter, returnează List». Typealias OnClickListener face codul să semene cu o declarație de interfață, dar fără overhead-ul creării unei interfețe sau clase abstracte separate. Lambdele și funcțiile anonime continuă să funcționeze ca de obicei — typealias nu necesită modificări în codul apelant.

Typealias cu generice

Typealias suportă parametri generalizați (generice), ceea ce îl face și mai flexibil. Se poate defini typealias Mapper = (T) -> R și folosi cu orice tipuri. Compilatorul substituie tipurile concrete în locul parametrilor la fiecare utilizare a aliasului, păstrând siguranța completă a tipurilor.

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

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

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

În listare, Mapper — un alias generalizat pentru orice transformare din T în R. Provider — furnizor de valoare (fabrică fără argumente). ListTransformer — funcție de transformare a listei. La apelul processNumbers(mapper: Mapper) compilatorul dezvoltă aliasul în (Int) -> String. Genericele fac typealias un instrument universal, potrivit pentru orice contexte fără duplicarea declarațiilor.

Typealias pentru clase imbricate și nume lungi

Clasele imbricate și tipurile parametrizate lungi — un alt domeniu în care typealias simplifică semnificativ codul. Dacă o clasă se află adânc în ierarhia de imbricare (Outer.Inner.Nested), referirea la ea prin numele complet aglomerează codul. Typealias scurtează acest acces și îl face mai lizibil. Acest lucru este deosebit de relevant pentru clasele din biblioteci terțe cu nume lungi.

// Alias pentru clasă imbricată
class NetworkResponse {
    class Error(val code: Int, val message: String)
}
typealias NetworkError = NetworkResponse.Error

// Alias pentru tip de bibliotecă lung
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
}

În exemplu, NetworkError — un alias pentru clasa imbricată NetworkResponse.Error. La importul typealias, NetworkError poate fi folosit ca un tip obișnuit, fără a dezvălui ierarhia de imbricare. JsonMap documentează că harta reprezintă un obiect JSON. UserId explică scopul Long în contextul respectiv — cititorul înțelege imediat că este un identificator de utilizator, nu un număr arbitrar. Totuși, typealias nu protejează împotriva transmiterii unui Long obișnuit acolo unde este așteptat UserId — pentru aceasta este necesar value class.

Typealias vs inline class: diferențe

Typealias și inline class (value class) rezolvă sarcini diferite, deși ambele introduc un nume nou pentru un tip. Typealias este doar un sinonim: variabila de tip UserId = Long acceptă orice Long fără verificare. Inline class învelește valoarea într-un tip nou care este verificat la compilare: transmiterea unui Long obișnuit acolo unde este așteptat inline class UserId este imposibilă fără o conversie explicită.

Tabelul arată diferența dintre cele două mecanisme. Typealias este potrivit pentru nume scurte și documentarea codului când nu este necesară o tipizare strictă. Inline class prin cuvântul cheie value class (anterior inline class) este necesar când este important să se distingă valori semantic diferite ale aceluiași tip primitiv. De exemplu, UserId și OrderId sunt ambele Long, dar transmiterea unuia acolo unde este așteptat celălalt este o eroare logică pe care value class o previne la compilare.