Reified Type Parameters: Accessing Generic Types at Runtime

Why it exists

On the JVM, type information for generics is normally erased at compile time. A List<String> becomes just a List at runtime, so you can't check an object against a generic type. This forces developers into clumsy workarounds, like passing String::class.java as an extra parameter to a function.

The mental model

Think of reified as making a generic type parameter "real" inside a function. It's a compile-time instruction that says, "Instead of erasing this type, find the actual type used at the call site and substitute it directly into the function's bytecode." The type is no longer just a placeholder; it's a concrete class you can work with.

How it works

Reified parameters are only possible on inline functions. When you call an inline function, the compiler copies its body directly to the call site. If that function has a reified type parameter, the compiler also replaces the generic T with the actual type argument. A call like myFunc<User>() results in compiled code where T is literally User. This allows you to perform runtime checks like obj is T or access the type's class with T::class.java.

When to use it

Use reified when a generic function needs to know about its type argument. This is perfect for building clean APIs. Examples include: deserializing JSON (moshi.adapter<User>().fromJson(jsonString)), finding views in Android, or creating type-safe database queries. It eliminates the need to pass class objects as arguments.

When not to use it

Do not use reified on non-inline functions, as it will cause a compile-time error. You also can't use it for properties or class type parameters. Be mindful that inlining, especially with large functions, can increase the size of the generated code, so use it where the API clarity and type safety benefits are clear.

One canonical example

Imagine finding a parent node of a specific type in a tree. Without reified types, the function is clunky: fun <T> findParentOfType(clazz: Class<T>): T?. The call looks like this: node.findParentOfType(MyNode::class.java). With a reified type, the function becomes inline fun <reified T> findParentOfType(): T?. The call is much cleaner and more intuitive: node.findParentOfType<MyNode>().