Generics in Kotlin can seem complex at first, but once you understand their power, they make your code more flexible and reusable. In this blog, we’ll break down generics in a simple way, focusing on generic functions and properties and best practices.

What Are Generics in Kotlin?

Generics allow you to write code that works with different data types without sacrificing type safety. Instead of specifying an exact type, you define a placeholder type that gets replaced with a real type at runtime.

For example, consider a function that prints any type of element. Instead of writing separate functions for Int, String, and other types, you can use generics to make it work for any type.

without generics, you might write:

fun printInt(value: Int) {
    println(value)
}

fun printString(value: String) {
    println(value)
}

With generics, you can simplify this:

fun <T> printValue(value: T) {
    println(value)
}

Now, printValue works with any type!

Generic Functions in Kotlin

A generic function uses a type parameter to make it more flexible. The type parameter is placed inside angle brackets (<>) before the function’s parameter list.

A Simple Generic Function

fun <T> printItem(item: T) {
    println(item)
}

fun main() {
    printItem(42)       // Works with Int
    printItem("Hello")  // Works with String
    printItem(3.14)     // Works with Double
}

• <T> is the type parameter.
• T is used as the parameter type inside the function.
• The function can now accept any type, making it more reusable.

Generic Function with Multiple Parameters

fun <T, U> pairItems(first: T, second: U): Pair<T, U> {
    return Pair(first, second)
}

fun main() {
    val pair = pairItems("Hello", 100)
    println(pair) // Output: (Hello, 100)
}

Here, we define two generic types, T and U, making the function even more flexible.

Generic Properties in Kotlin

You can also use generics with properties in classes.

class Box<T>(var content: T)

fun main() {
    val intBox = Box(42)
    val stringBox = Box("Hello, Kotlin Generics!")
    
    println(intBox.content)   // Outputs: 42
    println(stringBox.content) // Outputs: Hello, Kotlin Generics!
}

Here, Box<T> is a generic class where T represents any type. This allows us to create boxes for different types without duplicating code.

Read-Only Generic Properties

If you want a read-only generic property:

class ReadOnlyBox<T>(private val content: T) {<br>    fun getContent(): T = content<br>}

Since content is private, it can only be accessed via getContent().

Best Practices

Use Meaningful Type Parameter Names: Instead of <T>, consider using <Item> or <Element> for better readability.

Prefer Read-Only Properties: If a property doesn’t need modification, keep it read-only (val) to improve safety.

Avoid Unnecessary Generics: If a function doesn’t require type flexibility, don’t use generics unnecessarily. It can make the code harder to read.

Read the full article here: [Main Article URL]

Conclusion

Kotlin’s generics allow for reusable and type-safe code. By understanding generic functions and properties, you can write cleaner and more efficient Kotlin programs. Follow best practices, use it wisely, and keep your code readable.

Now that you have a solid grasp, try using generic functions and properties in your own Kotlin projects!