Reified in Kotlin — wat is het, syntaxis en toepassing

Wat is reified in Kotlin?

reified — is een modifier van de generic-parameter van een inline-functie die het type echt maakt (reify — “verwezenlijken”) in runtime. Zonder reified is het type T binnen een generic-functie niet toegankelijk — de compiler past type erasure toe en wist alle informatie over het type. reified dwingt de compiler om het concrete type op de aanroepplaats te substitueren, waardoor het toegankelijk wordt via T::class en de operator is.

Volgens Kotlin Survey by Kodee (2024) behoren reified type parameters tot de tien meest gevraagde Kotlin-functies — 52% van de ondervraagde ontwikkelaars gebruikt ze, voornamelijk voor het schrijven van generic-fabrieken, DI-containers en serializers. Reified is vooral populair in combinatie met Gson, Moshi en Kotlinx Serialization.

Technisch gezien is het mechanisme eenvoudig: bij het aanroepen van een inline-functie met een reified parameter kent de compiler het concrete type van het argument (Int, String, User) en substitueert het in plaats van T. In bytecode wordt de reified-parameter omgezet in een gewone Class, doorgegeven als een verborgen argument.

Gebruik reified voor het schrijven van generic-functies waarbij het type in runtime nodig is — instanties maken, typecontroles, Class verkrijgen voor reflectie of serialisatie.

Het probleem van type erasure in generics

Type erasure — het mechanisme van Java en Kotlin waarbij informatie over generic-parameters wordt gewist tijdens de compilatie. In bytecode worden List en List gewoon List. Dit is gedaan voor achterwaartse compatibiliteit met Java 1.4, waar generics niet bestonden, maar creëert beperkingen bij het werken met typen in runtime.

// ❌ Fout: Kan instantie van gewist type niet controleren
fun <T> checkType(value: Any) {
    if (value is T) { // type erasure — T is onbekend
        println("Type komt overeen")
    }
}

// ✅ Solution: pass Class as parameter
fun <T> checkTypeWithClass(
    value: Any,
    clazz: Class<T>
) {
    if (clazz.isInstance(value)) {
        println("Type komt overeen")
    }
}

In het voorbeeld compileert checkType niet vanwege type erasure — de compiler weet niet welk type in plaats van T te substitueren. In checkTypeWithClass is het probleem opgelost door Class expliciet door te geven, maar dit vereist boilerplate: elke aanroep gaat gepaard met .java of ::class.java. reified elimineert deze boilerplate volledig.

Syntaxis van reified en werkingsmechanisme

De modifier reified wordt voor de generic-parameter in een inline-functie geplaatst. De functie moet verplicht inline zijn — de compiler moet de mogelijkheid hebben om het concrete type te substitueren tijdens de inlining-fase.

inline fun <reified T> isA(value: Any): Boolean {
    return value is T
}

fun main() {
    println(isA<String>("Hallo")) // true
    println(isA<Int>("Hallo"))  // false
}

Tijdens de compilatie wordt de aanroep isA("Hello") vervangen door de controle value is String. De aanroep isA("Hello") — door value is Int. Het type wordt letterlijk gesubstitueerd, wat het gebruik mogelijk maakt van is, as, ::class en andere bewerkingen die niet beschikbaar zijn bij type erasure.

Decompilatie van een reified-functie

Als we de bytecode van isA("Hello") decompileren, toont IntelliJ IDEA ongeveer het volgende resultaat in Java: String.class.isInstance(value). In plaats van de generic-parameter heeft de compiler concreet java.lang.String.class gesubstitueerd — geen reflectie met het zoeken naar een type op naam, alleen een directe verwijzing naar de klasse.

Typecontroles met reified: is en as

De meest voorkomende toepassing van reified — typecontrole via de operator is. In een gewone generic-functie compileert value is T niet. Met reified werkt dit als met een gewone klasse: value is String, value is List (bijna — rekening houdend met de beperkingen van reified voor geparametriseerde typen).

inline fun <reified T> List<Any>.filterByType(): List<T> {
    return this.filter { it is T }.map { it as T }
}

val mixed = listOf("a", 1, "b", 2)
val strings = mixed.filterByType<String>() // ["a", "b"]
val ints = mixed.filterByType<Int>()    // [1, 2]

De extensiefunctie filterByType filtert de lijst en laat alleen elementen van het opgegeven type over. Zonder reified zou men filterByType(list) moeten schrijven met de parameter Class. Met reified leest de aanroep als een natuurlijke bewerking op de lijst, wat de leesbaarheid van gegevensverwerkingsketens verbetert.

Volgens gegevens uit de Kotlin Coroutines Guide (JetBrains, 2025) worden reified typecontroles gebruikt in launch en async voor het doorgeven van het resultaattype van de coroutine, waardoor expliciete typering in de meeste gevallen wordt vermeden.

Reflectie met reified: instanties maken en toegang tot Class

reified geeft toegang tot T::class — een verwijzing naar KClass, waaruit via .java de Java Class kan worden verkregen. Dit opent mogelijkheden voor het maken van instanties via reflectie, werken met serializers en het verkrijgen van klasseannotaties tijdens de uitvoering.

inline fun <reified T> createInstance(): T =
    T::class.java.getDeclaredConstructor().newInstance()

// Gebruik
data class User(val name: String = "default")
val user = createInstance<User>()

// Serialisatie met Gson
inline fun <reified T> Gson.fromJson(json: String): T =
    this.fromJson(json, T::class.java)

// Annotaties verkrijgen
inline fun <reified T> hasAnnotation<A>(): Boolean where A : Annotation =
    T::class.java.isAnnotationPresent(A::class.java)

De wrapper fromJson voor Gson — een klassiek voorbeeld van het gebruik van reified in productie. In plaats van gson.fromJson(json, User::class.java) kan men gson.fromJson(json) schrijven. Dit lijkt een kleine verbetering, maar in een project met honderden serialisatie-aanroepen vermindert reified de boilerplate aanzienlijk en maakt de code schoner.

Beperkingen van reified en alternatieven

reified heeft beperkingen. Ten eerste — werkt alleen binnen inline-functies. Als een functie niet inline kan worden gemaakt (bijvoorbeeld recursief of te groot), is reified niet beschikbaar. Ten tweede — reified kan niet direct worden gebruikt met suspend-functies, alleen via inline wrappers.

Ten derde — reified werkt niet volledig met geparametriseerde typen. Bijvoorbeeld filterByType>() kan een onverwacht resultaat geven, omdat reified voor geparametriseerde typen alleen het ruwe type (List) behoudt, zonder de generic-argumenten te specificeren. Voor volledige controle van geparametriseerde typen is reflectie met TypeToken vereist.

Voor gevallen waarin reified niet beschikbaar is, gebruik dan het patroon met expliciete overdracht van Class of TypeToken uit bibliotheken (bijvoorbeeld Gson TypeToken of Jackson TypeReference). Deze benadering werkt in elke functie, maar vereist boilerplate en is minder handig.