Kotlin is a powerful language that brings many improvements over Java, especially when it comes to generics. One of its unique features is reified type parameters, which solve some of the limitations of Java’s generics. However, there are certain restrictions on reified type parameters that developers should be aware of. In this post, we’ll dive deep into these restrictions, understand why they exist, and explore how to work around them.

What Are Reified Type Parameters?

In Kotlin, generic type parameters are usually erased at runtime due to type erasure, just like in Java. However, by using the inline keyword along with the reified modifier, you can retain type information at runtime.

Without Reified Type Parameters

fun <T> getClassType(): Class<T> {
    return T::class.java // Error: Cannot use 'T' as a reified type parameter
}

The above code will not work because T is erased at runtime, making it impossible to retrieve its class type.

With Reified Type Parameters

inline fun <reified T> getClassType(): Class<T> {
    return T::class.java
}

fun main() {
    println(getClassType<String>()) // Output: class java.lang.String
}

By marking T as reified, we can access its type at runtime, allowing operations like T::class.java without issues.

Key Restrictions on Reified Type Parameters

While reified type parameters are incredibly useful, they come with some limitations. Let’s explore these restrictions in detail.

1. Reified Type Parameters Can Only Be Used in Inline Functions

One of the biggest restrictions on reified type parameters is that they are only allowed inside inline functions. If you try to use them in regular functions, you’ll get a compilation error.

fun <reified T> someFunction() { // Error: Type parameter T cannot be reified
    println(T::class.java)
}

Why Does This Restriction Exist?

Kotlin’s reified type parameters work by inlining the function, meaning the actual type is substituted at the call site. Without inlining, the type information would still be erased, making it impossible to retain the generic type at runtime.

Workaround: To use reified types, always mark your function as inline:

inline fun <reified T> someFunction() {
    println(T::class.java)
}

2. Reified Types Cannot Be Used in Class-Level Generics

Reified type parameters are tied to functions, not classes. If you try to use a reified type in a class definition, Kotlin will complain:

class MyClass<reified T> {  // This is not allowed!
    fun printType() {
        println("The type is: ${T::class.simpleName}")
    }
}

Error:

Reified type parameters are only allowed for inline functions.

Workaround: Instead of using a class-level generic with reified, define an inline function inside the class:

class MyClass<T> {
    inline fun <reified T> printType() {
        println("The type is: ${T::class.simpleName}")
    }
}

3. Reified Type Parameters Cannot Be Used in Class-Level Properties

Another important restriction on reified type parameters is that they cannot be used as class properties.

class Example<T> {
    val type = T::class // Error: Cannot use 'T' as a reified type parameter
}

Since reified type parameter require inline functions to retain type information, they cannot be stored in class properties. The class itself does not have access to the type at runtime due to type erasure.

Workaround: If you need to store a type reference, you can pass the KClass instance explicitly:

class Example<T>(private val clazz: Class<T>) {
    fun getType(): Class<T> = clazz
}

fun main() {
    val example = Example(String::class.java)
    println(example.getType()) // Output: class java.lang.String
}

4. Cannot Create New Instances of Reified Types

Unlike Java’s reflection-based approach (T::class.java.newInstance()), Kotlin prevents the direct instantiation of reified types:

inline fun <reified T> createInstance(): T {
    return T()  // Compilation error!
}

Error:

Cannot create an instance of T because it has no zero-argument constructor.

Workaround: Pass a factory function or a class reference:

inline fun <reified T> createInstance(factory: () -> T): T {
    return factory()
}

Conclusion

Reified type parameters are a powerful feature in Kotlin, allowing us to retain type information at runtime. However, there are several restrictions on reified type parameters to be mindful of:

• Reified types only work in inline functions.
• They cannot be used in class-level generics or properties.
• You cannot instantiate a reified type directly.

By keeping these points in mind, you can write more efficient and type-safe Kotlin code while leveraging the full power of reified type parameters.