Typealias — wat is het, syntaxis en toepassing in Kotlin

Wat is typealias?

Typealias (type-alias) — een declaratie die een alternatieve naam introduceert voor een bestaand type. Syntaxis: typealias NieuweNaam = BestaandType. Na declaratie kan NieuweNaam overal worden gebruikt waar BestaandType wordt verwacht — de compiler behandelt ze als hetzelfde type. Op bytecode-niveau laat typealias geen sporen achter: alle informatie over de alias wordt tijdens de compilatiefase gewist.

Het hoofddoel van typealias is het verbeteren van de leesbaarheid van code. In plaats van een lange handtekening fun process(callback: (Result) -> Unit) kan men typealias Callback = (Result) -> Unit schrijven en Callback gebruiken als parametertype. Dit is vooral nuttig wanneer hetzelfde functionele type op meerdere plaatsen in de code voorkomt: de alias dient als enig definitiepunt en documenteert het doel van het type.

Typealias creëert geen nieuw type — het is slechts een synoniem. Variabelen van het type Callback en (Result) -> Unit zijn volledig uitwisselbaar. De compiler geeft geen fout als een lambda direct wordt doorgegeven aan een functie die Callback verwacht. Dit onderscheidt typealias van inline class (value class), die een nieuw wrapper-type creëert met controle tijdens compilatie. Typealias is een hernoeming, geen wrapper.

Typealias voor functionele types

Het meest voorkomende gebruiksscenario voor typealias in Kotlin zijn functionele types. Lange handtekeningen zoals (Int, String) -> Boolean of (List) -> Result maken code moeilijk leesbaar. Typealias verandert ze in korte betekenisvolle namen die het doel van de functie documenteren: typealias Validator = (String) -> Boolean specificeert dat dit een stringvalidator is.

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

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

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

// Gebruik in klasse
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

In het voorbeeld verbergt typealias UserFilter het complexe functionele type (List) -> List achter een korte naam. De handtekening findUsers wordt leesbaar: «ontvangt UserFilter, retourneert List». Typealias OnClickListener maakt code vergelijkbaar met een interface-declaratie, maar zonder de overhead van het maken van een aparte interface of abstracte klasse. Lambdas en anonieme functies werken zoals gewoonlijk — typealias vereist geen wijzigingen in de aanroepende code.

Typealias met generieken

Typealias ondersteunt generieke parameters, wat het nog flexibeler maakt. Men kan typealias Mapper = (T) -> R definiëren en met elk type gebruiken. De compiler substitueert concrete types in plaats van de parameters bij elk gebruik van de alias, met behoud van volledige typeveiligheid.

// Generieke 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() }
}

In de listing is Mapper — een generieke alias voor elke transformatie van T naar R. Provider — een waardeleverancier (fabriek zonder argumenten). ListTransformer — een functie voor het transformeren van een lijst. Bij de aanroep processNumbers(mapper: Mapper) ontvouwt de compiler de alias naar (Int) -> String. Generieken maken typealias tot een universeel hulpmiddel dat geschikt is voor elke context zonder duplicatie van declaraties.

Typealias voor geneste klassen en lange namen

Geneste klassen en lange geparametriseerde types — een ander gebied waar typealias de code aanzienlijk vereenvoudigt. Als een klasse diep in de nestingshiërarchie zit (Outer.Inner.Nested), vervuilt verwijzing ernaar met de volledige naam de code. Typealias verkort deze toegang en maakt het leesbaarder. Dit is vooral relevant voor klassen uit bibliotheken van derden met lange namen.

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

// Alias voor lang bibliotheektype
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
}

In het voorbeeld is NetworkError — een alias voor de geneste klasse NetworkResponse.Error. Bij import van typealias kan NetworkError worden gebruikt als een gewoon type, zonder de nestingshiërarchie te onthullen. JsonMap documenteert dat de kaart een JSON-object voorstelt. UserId verklaart het doel van Long in de specifieke context — de lezer begrijpt onmiddellijk dat dit een gebruikersidentificatie is, geen willekeurig getal. Typealias beschermt echter niet tegen het doorgeven van een gewone Long waar UserId wordt verwacht — daarvoor is value class nodig.

Typealias vs inline class: verschillen

Typealias en inline class (value class) lossen verschillende taken op, hoewel beide een nieuwe naam voor een type introduceren. Typealias is slechts een synoniem: een variabele van het type UserId = Long accepteert elke Long zonder controle. Inline class wikkelt de waarde in een nieuw type dat tijdens compilatie wordt gecontroleerd: het doorgeven van een gewone Long waar inline class UserId wordt verwacht, is onmogelijk zonder expliciete conversie.

De tabel toont het verschil tussen de twee mechanismen. Typealias is geschikt voor korte namen en codedocumentatie wanneer strikte typering niet vereist is. Inline class via het sleutelwoord value class (voorheen inline class) is nodig wanneer het belangrijk is om semantisch verschillende waarden van hetzelfde primitieve type te onderscheiden. Bijvoorbeeld, UserId en OrderId zijn beide Long, maar het doorgeven van de ene waar de andere wordt verwacht is een logische fout die value class tijdens compilatie voorkomt.