Amol Pawar

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.

Kotlin is a powerful and expressive programming language that brings many modern features to Android and backend development. One of its standout features (object in kotlin) is the object keyword, which provides a clean and concise way to define singleton objects, companion objects, and anonymous objects. If you’re coming from Java, understanding how Kotlin handles objects can significantly improve your code’s readability and efficiency.

In this guide, we’ll explore Kotlin’s object keyword in depth, covering its different use cases with examples.

What is an Object in Kotlin?

In Kotlin, an object is an instance of a class that is created automatically and can be referenced directly. Unlike traditional class instantiation, where you need to explicitly create an instance using new, Kotlin’s object keyword allows you to create singletons and anonymous objects efficiently.

Objects in Kotlin can be categorized into:

• Singleton Objects
• Companion Objects
• Anonymous Objects

Each of these serves a different purpose. Let’s break them down one by one.

Singleton Object in Kotlin

A singleton is a class that has only one instance throughout the program. Instead of creating multiple instances, you define a singleton using object.

object Database {
    val name = "MyDatabase"
    
    fun connect() {
        println("Connected to $name")
    }
}

fun main() {
    Database.connect() // Output: Connected to MyDatabase
}

• No need for manual instantiation — The Database object is automatically created.
• Thread-safe — Since there is only one instance, it avoids issues with multiple instances.
• Useful for managing shared resources, such as database connections or network clients.

Companion Objects: Static-like Behavior in Kotlin

Unlike Java, Kotlin does not have static methods. Instead, you can use companion objects inside classes to define functions and properties that belong to the class itself rather than its instances.

class User(val name: String) {
    companion object {
        fun createGuest() = User("Guest")
    }
}

fun main() {
    val guest = User.createGuest()
    println(guest.name) // Output: Guest
}

Why Use Companion Objects?

• Acts like a static method in Java — You don’t need to create an instance of User to call createGuest().
• Encapsulates related functionality — Keeps utility functions inside the class instead of defining them separately.
• Can implement interfaces — Unlike static methods in Java, a companion object can extend interfaces.

Anonymous Objects: One-Time Use Classes 

Sometimes, you need an object only once, such as for event listeners or implementing an interface on the fly. Kotlin provides anonymous objects (Object Expression) for this purpose.

interface ClickListener {
    fun onClick()
}

fun main() {
    val buttonClickListener = object : ClickListener {
        override fun onClick() {
            println("Button clicked!")
        }
    }
    buttonClickListener.onClick() // Output: Button clicked!
}

Key Benefits:

• No need to create a separate class — Saves boilerplate code.
• Good for event listeners and callbacks — Common in Android development.
• Short-lived instances — Automatically garbage collected when no longer needed.

Object Expression vs. Object Declaration

There are two primary ways to use objects in Kotlin: Object Expressions and Object Declarations. Let’s compare them:

When to Use Objects in Kotlin?

• Use a singleton object when you need a single, shared instance (e.g., logging, database connections).
• Use a companion object when you need static-like methods and properties within a class.
• Use an anonymous object when you need a temporary implementation of an interface or class (e.g., callbacks, event listeners).

Conclusion

Kotlin’s object keyword is a powerful tool that simplifies singleton patterns, enables static-like functionality, and allows for concise anonymous implementations. By understanding singleton objects, companion objects, and anonymous objects, you can write cleaner, more efficient, and idiomatic Kotlin code.

Kotlin is a powerful, modern programming language with robust support for generics. But when dealing with generics, you often run into the concept of variance, which can be tricky to grasp at first. In this post, we’ll break down Kotlin variance in a simple and engaging way, ensuring you fully understand generics and subtyping.

What is Kotlin Variance?

Variance defines how generic types relate to each other in the context of subtyping. Consider this:

open class Animal
class Dog : Animal()

In normal inheritance, Dog is a subtype of Animal. But does List<Dog> automatically become a subtype of List<Animal>? The answer is no, unless we explicitly declare variance.

Kotlin provides three ways to handle variance:

• Covariance (out)
• Contravariance (in)
• Invariance (default behavior)

Let’s explore each of these concepts with examples.

Covariance (out) – Producer

Covariant types allow a generic type to be a subtype of another generic type when its type parameter is only used as an output (producer). It is declared using the out keyword.

interface Producer<out T> {
    fun produce(): T
}

This means that Producer<Dog> can be used where Producer<Animal> is expected:

class DogProducer : Producer<Dog> {
    override fun produce(): Dog = Dog()
}

val producer: Producer<Animal> = DogProducer() // Works fine

Why Use out?

• It ensures type safety.
• Used when a class only returns values of type T.
• Common in collections like List<T>, which can only produce items, not modify them.

Example:

fun feedAnimals(producer: Producer<Animal>) {
    val animal: Animal = producer.produce()
    println("Feeding ${animal::class.simpleName}") //O/P - Feeding Dog
}

Since Producer<Dog> is a subtype of Producer<Animal>, this works without any issues.

Contravariance (in) – Consumer

Contravariant types allow a generic type to be a supertype of another generic type when its type parameter is only used as an input (consumer). It is declared using the in keyword.

interface Consumer<in T> {
    fun consume(item: T)
}

This means that Consumer<Animal> can be used where Consumer<Dog> is expected:

class AnimalConsumer : Consumer<Animal> {
    override fun consume(item: Animal) {
        println("Consuming ${item::class.simpleName}")
    }
}

val consumer: Consumer<Dog> = AnimalConsumer() // Works fine

Why Use in?

• Again it ensures type safety.
• Used when a class only takes in values of type T.
• Common in function parameters, like Comparator<T>.

Example:

fun addDogsToShelter(consumer: Consumer<Dog>) {
    consumer.consume(Dog())
}

Since Consumer<Animal> is a supertype of Consumer<Dog>, this works perfectly.

Invariance (Default Behavior: No in or out)

By default, generics in Kotlin are invariant, meaning Box<Dog> is NOT a subtype or supertype of Box<Animal>, even though Dog is a subtype of Animal. Means, they do not support substitution for subtypes or supertypes.

class Box<T>(val item: T)

val dogBox: Box<Dog> = Box(Dog())
val animalBox: Box<Animal> = dogBox // Error: Type mismatch

Why?

Without explicit variance, Kotlin prevents unsafe assignments. If variance is not declared, Kotlin assumes that T can be both produced and consumed, making it unsafe to assume subtyping.

Star Projection (*) – When Type is Unknown

Sometimes, you don’t know the exact type parameter but still need to work with a generic class. Kotlin provides star projection (*) to handle such cases.

Example:

fun printList(list: List<*>) {
    for (item in list) {
        println(item) // Treated as Any?
    }
}

A List<*> means it could be List<Any>, List<String>, List<Int>, etc., but we cannot modify it because we don’t know the exact type.

Best Practices for Kotlin Variance

• Use out when the type is only produced (e.g., List<T>).
• Use in when the type is only consumed (e.g., Comparator<T>).
• Keep generics invariant unless variance is required.
• Use star projections (*) when you don’t know the type but need read access.

Conclusion

Understanding Kotlin Variance is crucial for writing flexible and type-safe code. Covariance (out) is used for producers, contravariance (in) for consumers, and invariance when both roles exist. By mastering Kotlin Variance concepts, you can work effectively with generics and subtyping in Kotlin.