Typealias — mi ez, szintaxis és alkalmazása Kotlinban

Mi az a typealias?

Typealias (típus álnév) — egy deklaráció, amely alternatív nevet vezet be egy meglévő típus számára. Szintaxis: typealias ÚjNév = MeglévőTípus. A deklaráció után az ÚjNév bárhol használható, ahol a MeglévőTípus várható — a fordító ugyanazon típusként kezeli őket. A bájtkód szintjén a typealias nem hagy nyomot: az álnévvel kapcsolatos összes információ törlődik a fordítási szakaszban.

A typealias fő célja a kód olvashatóságának javítása. A hosszú aláírás fun process(callback: (Result) -> Unit) helyett írhatjuk typealias Callback = (Result) -> Unit és használhatjuk a Callback-et paramétertípusként. Ez különösen akkor hasznos, ha ugyanaz a funkcionális típus több helyen ismétlődik a kódban: az álnév egységes definíciós pontként szolgál és dokumentálja a típus célját.

A typealias nem hoz létre új típust — ez csak egy szinonima. A Callback és (Result) -> Unit típusú változók teljesen felcserélhetők. A fordító nem ad hibát, ha egy Callback-et váró függvénybe közvetlenül lambdát adunk át. Ez különbözteti meg a typealias-t az inline class-tól (value class), amely egy új burkoló típust hoz létre fordítási ellenőrzéssel. A typealias átnevezés, nem burkolás.

Typealias funkcionális típusokhoz

A typealias leggyakoribb alkalmazási forgatókönyve Kotlinban a funkcionális típusok. A hosszú aláírások, mint (Int, String) -> Boolean vagy (List) -> Result, nehezítik a kód olvasását. A typealias rövid, jelentéssel bíró nevekké alakítja őket, amelyek dokumentálják a függvény célját: a typealias Validator = (String) -> Boolean meghatározza, hogy ez egy sztringérvényesítő.

// Typealias nélkül
fun findUsers(
    filter: (List<User>) -> List<User>
): List<User>

// Typealias-szal
typealias UserFilter = (List<User>) -> List<User>

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

// Használat osztályban
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

A példában a typealias UserFilter az összetett funkcionális típust (List) -> List egy rövid név mögé rejti. A findUsers aláírása olvashatóvá válik: «UserFilter-t fogad, List-t ad vissza». A typealias OnClickListener a kódot interfészdeklarációhoz hasonlóvá teszi, de külön interfész vagy absztrakt osztály létrehozásának többletterhe nélkül. A lambdák és névtelen függvények továbbra is a megszokott módon működnek — a typealias nem igényel változtatásokat a hívó kódban.

Typealias generikusokkal

A typealias támogatja az általánosított paramétereket (generikusokat), ami még rugalmasabbá teszi. Definiálható typealias Mapper = (T) -> R és bármilyen típussal használható. A fordító konkrét típusokat helyettesít a paraméterek helyére az álnév minden használatakor, megőrizve a teljes típusbiztonságot.

// Generikus 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 típusa (Int) -> String
}

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

A listában a Mapper — egy általánosított álnév bármilyen T-ből R-be történő átalakításhoz. Provider — értékszolgáltató (argumentumok nélküli gyár). ListTransformer — lista átalakító függvénye. A processNumbers(mapper: Mapper) hívásakor a fordító az álnevet (Int) -> String-re bontja ki. A generikusok univerzális eszközzé teszik a typealias-t, amely a deklarációk többszörözése nélkül bármilyen kontextusban alkalmazható.

Typealias beágyazott osztályokhoz és hosszú nevekhez

A beágyazott osztályok és hosszú paraméterezett típusok — egy másik terület, ahol a typealias jelentősen egyszerűsíti a kódot. Ha egy osztály mélyen van a beágyazási hierarchiában (Outer.Inner.Nested), a teljes néven való hivatkozás elborítja a kódot. A typealias lerövidíti ezt az elérést és olvashatóbbá teszi. Ez különösen fontos a harmadik féltől származó könyvtárak hosszú nevű osztályai esetében.

// Álnév beágyazott osztályhoz
class NetworkResponse {
    class Error(val code: Int, val message: String)
}
typealias NetworkError = NetworkResponse.Error

// Álnév hosszú könyvtártípushoz
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
}

A példában a NetworkError — egy álnév a NetworkResponse.Error beágyazott osztályhoz. A typealias importálásakor a NetworkError használható szokásos típusként, anélkül, hogy felfednénk a beágyazási hierarchiát. A JsonMap dokumentálja, hogy a térkép egy JSON-objektumot reprezentál. A UserId magyarázza a Long célját az adott kontextusban — az olvasó azonnal megérti, hogy ez egy felhasználói azonosító, nem egy tetszőleges szám. A typealias azonban nem véd a sima Long átadása ellen ott, ahol UserId várható — ehhez value class szükséges.

Typealias vs inline class: különbségek

A typealias és az inline class (value class) különböző feladatokat old meg, bár mindkettő új nevet vezet be egy típus számára. A typealias csak egy szinonima: a UserId = Long típusú változó bármilyen Long-ot elfogad ellenőrzés nélkül. Az inline class egy új típusba csomagolja az értéket, amelyet a fordítás során ellenőriznek: egy sima Long átadása oda, ahol inline class UserId várható, explicit konverzió nélkül lehetetlen.

A táblázat a két mechanizmus közötti különbséget mutatja. A typealias rövid nevekhez és kód dokumentálásához alkalmas, ha nincs szükség szigorú tipizálásra. Az inline class a value class kulcsszóval (korábban inline class) akkor szükséges, ha fontos megkülönböztetni ugyanazon primitív típus szemantikailag különböző értékeit. Például a UserId és az OrderId egyaránt Long, de az egyik átadása a másik helyére logikai hiba, amelyet a value class a fordítás során megelőz.