Typealias — was es ist, Syntax und Verwendung in Kotlin

Was ist typealias?

Typealias (type alias) is a declaration that introduces an alternative name for an existing type. Syntax: typealias NeuerName = VorhundenerTyp. Nach der Deklaration kann NeuerName überall dort verwendet werden, wo VorhundenerTyp erwartet wird — der Compiler behundelt sie als denselben Typ. Auf Bytecode-Ebene hinterlässt typealias keine Spuren: Alle Alias-Informationen werden zur Compile-Zeit gelöscht.

Der Hauptzweck von typealias ist die Verbesserung der Lesbarkeit des Codes. Anstelle einer ausführlichen Signatur fun process(callback: (Result) -> Unit), kann man typealias Callback = (Result) -> Unit schreiben und Callback als Parametertyp verwenden. Dies ist besonders nützlich, wenn derselbe funktionale Typ an mehreren Stellen im Code wiederholt wird: der Alias dient als einziger Definitionspunkt und dokumentiert den Zweck des Typs.

Typealias erstellt keinen neuen Typ — it is just a synonym. Variablen vom Typ Callback und (Result) -> Unit sind vollständig austauschbar. Der Compiler gibt keinen Fehler aus, wenn eine Lambda direkt an eine Funktion übergeben wird, die Callback erwartet. Dies unterscheidet typealias von der Inline-Klasse (Value Class), die einen neuen Wrappertyp mit Compile-Zeit-Prüfung erstellt. Typealias ist Umbenennung, nicht Umhüllung.

Typealias für funktionale Typen

Der häufigste Anwendungsfall für typealias in Kotlin sind functional types. Long signatures like (Int, String) -> Boolean oder (List) -> Result machen Code schwer lesbar. Typealias verwundelt sie in kurze, aussagekräftige Namen, die den Zweck der Funktion dokumentieren: typealias Validator = (String) -> Boolean gibt an, dass dies ein String-Validator ist.

// 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 = {}
}

Im Beispiel verbirgt der Typealias UserFilter den komplexen funktionalen Typ (List) -> List hinter einem kurzen Namen. Die Signatur von findUsers wird lesbar: "erwartet UserFilter, gibt List zurück". The typealias OnClickListener lässt den Code wie eine Interface-Deklaration aussehen, jedoch ohne den Overhead eines separaten Interfaces oder einer abstrakten Klasse. Lambdas und anonyme Funktionen funktionieren weiterhin wie gewohnt — typealias erfordert keine Änderungen am aufrufenden Code.

Typealias mit Generics

Typealias supports generic parameters, was es noch flexibler macht. Man kann typealias Mapper = (T) -> R definieren und mit beliebigen Typen verwenden. Der Compiler ersetzt bei jeder Verwendung des Alias die Parameter durch spezifische Typen und bewahrt so die vollständige Typsicherheit.

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

In der Auflistung ist Mapper ein generischer Alias für jede Transformation von T nach R. Provider ist ein Werte-Lieferant (eine Fabrik ohne Argumente). ListTransformer ist eine Listentransformationsfunktion. Beim Aufruf von processNumbers(mapper: Mapper), expundiert der Compiler den Alias zu (Int) -> String. Generics machen typealias zu einem universellen Werkzeug, das ohne Duplizieren von Deklarationen für jeden Kontext geeignet ist.

Typealias für verschachtelte und lange Namen

Nested classes und long parameterized types are another area where typealias significantly simplifies code. Wenn eine Klasse tief in einer Verschachtelungshierarchie (Outer.Inner.Nested) liegt, verunreinigt der vollständige Name den Code. Typealias verkürzt solchen Zugriff und macht ihn lesbarer. Dies ist besonders relevant für Klassen aus Drittanbieter-Bibliotheken mit langen Namen.

// 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
}

Im Beispiel ist NetworkError ein Alias für die verschachtelte Klasse NetworkResponse.Error. Durch Importieren des Typealias kann NetworkError als normaler Typ verwendet werden, ohne die Verschachtelungshierarchie offenzulegen. JsonMap dokumentiert, dass die Map ein JSON-Objekt darstellt. UserId verdeutlicht den Zweck von Long in einem bestimmten Kontext — der Leser versteht sofort, dass es sich um eine Benutzerkennung hundelt, nicht um eine beliebige Zahl. Allerdings verhindert typealias nicht, dass ein einfacher Long dort übergeben wird, wo UserId erwartet wird — dafür wird eine Value Class benötigt.

Typealias vs Inline Class: Unterschiede

Typealias und inline class (value class) lösen unterschiedliche Probleme, obwohl beide einen neuen Namen für einen Typ einführen. Typealias ist nur ein Synonym: Eine Variable vom Typ UserId = Long akzeptiert jedes Long ohne Prüfung. Die Inline Class umhüllt einen Wert in einem neuen Typ, der zur Compile-Zeit geprüft wird: Ein einfaches Long kann nicht dort übergeben werden, wo eine Inline Class UserId erwartet wird, ohne explizite Konvertierung.

Die Tabelle zeigt den Unterschied zwischen den beiden Mechanismen. Typealias is suitable for concise names und code documentation when strict typing is not required. Inline Class via the value class Schlüsselwort (früher inline class) wird benötigt, wenn semantisch unterschiedliche Werte desselben primitiven Typs unterschieden werden müssen. For example, UserId und OrderId are both Long, but passing one where the other is expected is a logical error that value class prevents at compile time.