Enhancing Your Kotlin Codebase with Lesser-Known Gems and Smart Techniques

Photo by Road Trip with Raj on Unsplash

@JvmInline
value class Meter(val value: Double) {
    fun toCentimeter() = value * 100
}

fun main() {
    val length = Meter(5.0)
    println("Length in centimeters: ${length.toCentimeter()}")
}

Explanation — In this example, we define an inline class Meter that wraps a Double value. The toCentimeter function showcases how inline classes can provide specialized functionality without introducing performance overhead.

2. Type Aliases — Enhancing Readability

Photo by Jamie Street on Unsplash

Example — Type aliases allow us to create meaningful names for existing types, improving code comprehension.

typealias EmployeeId = String

val employeeList = mutableListOf<Employee>()

fun addEmployee(employeeId: EmployeeId, employeeName: String){
    employeeList.add(Employee(employeeId, employeeName))
}

fun printEmployees(){
    employeeList.forEach {
        println(it)
    }
}

data class Employee(val employeeId: EmployeeId, val employeeName: String)

fun main(){
    addEmployee("SX-2322", "John")
    addEmployee("BX-1232", "Ron")
    printEmployees()

Type Alias Example

Explanation — Here, we create a type alias EmployeeId for the String type. This enhances readability and clarifies the purpose of the employeeId parameter.

3. Sealed Classes — A Hierarchical Approach to Enums

Example — Sealed classes provide a hierarchical approach to defining enums, allowing us to represent complex states with their own data.

sealed class Result
data class Success(val data: Any) : Result()
data class Error(val message: String) : Result()

fun handleResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

fun main(){
    handleResult(Success(200))
    handleResult(Error("Not Found"))

Sealed Class Example

Explanation — In this example, we define a sealed class Result that has two sub-classes — Success and Error. The handleResult function uses a when expression to handle instances of Result and provides custom behavior for each case.

4. Delegated Properties — Property Management Made Elegant

Photo by Kilimanjaro STUDIOz on Unsplash

Example — Delegated properties enable us to manage properties with reusable behavior, enhancing code readability and modularity.

import kotlin.reflect.KProperty

class Temperature {
    var value: Double by ObservableProperty(25.0)
}

class ObservableProperty(initialValue: Double) {
    private var currentValue = initialValue

    operator fun getValue(thisRef: Any?, property: KProperty<*>): Double {
        println("Getting property ${property.name}: $currentValue")
        return currentValue
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: Double) {
        println("Setting property ${property.name} to $newValue")
        currentValue = newValue
    }
}

fun main() {
    val temperature = Temperature()
    println("Initial Temperature: ${temperature.value}")
    temperature.value = 30.0
    println("Updated Temperature: ${temperature.value}")
}

Delegated Property Example

Explanation — In this example, we have a Temperature class with a property called value. Instead of directly storing the temperature value, we use a delegated property to manage it. The delegated property is an instance of the ObservableProperty class.

1. The ObservableProperty class defines two important operators — getValue and setValue. These operators handle the behavior of getting and setting the property value.
2. When the property is accessed (get), the getValue operator is invoked. It prints a message indicating that the property is being retrieved and returns the current value stored in the currentValue variable.
3. When the property is assigned (set), the setValue operator is invoked. It prints a message indicating that the property is being set to a new value, and then updates the currentValue variable with the new value.

In the main function, we create an instance of the Temperature class. When we access and update the value property, the delegated property’s behavior defined in the ObservableProperty class is executed. This provides a clean way to encapsulate the property’s behavior and enables us to manage properties with reusable logic.

By using delegated properties, you can achieve elegant and modular property management, leading to improved code organization and maintainability.

5. Pattern Matching with When Expressions

Photo by Ingo Stiller on Unsplash

Example — Kotlin’s when expression allows for powerful pattern matching and branching.

sealed class Animal
data class Dog(val name: String) : Animal()
data class Cat(val name: String) : Animal()
data class Lion(val name: String) : Animal()

fun soundOfAnimal(animal: Animal): String {
    return when (animal) {
        is Dog -> "Woof"
        is Cat -> "Meow"
        is Lion -> "Roar"
    }
}

fun main() {
    val mocha = Dog("Mocha")
    val roomba = Lion("Roomba")
    
    println(soundOfAnimal(mocha))
    println(soundOfAnimal(roomba))
}

When Expression Example

fun safeLength(text: String?): Int {
    return text?.length ?: 0
}

fun main() {
    val name: String? = null
    val length = safeLength(name)
    println("Length: $length")
}

Null Safety Example

Explanation — The safeLength function returns the length of a string if it’s not null, otherwise defaulting to 0. This showcases Kotlin’s null-safe programming paradigm.

2. Extension Functions — Power of Extensibility

Photo by Srinivasan Venkataraman on Unsplash

Example — Extension functions allow you to extend existing classes with new functionality.

fun String.capitalizeWords(): String {
    return this.split(" ").joinToString(" ") { it.capitalize() }
}

fun main() {
    val input = "hello world"
    val capitalized = input.capitalizeWords()
    println("Capitalized: $capitalized")
}

Extension Functions Example

Explanation — In this example, we define an extension function capitalizeWords for the String class, enabling capitalization of each word in a sentence.

3. Inline Functions — Balancing Performance and Code Size

Example — Inline functions can enhance performance, but their usage requires consideration of code size.

inline fun measureTime(block: () -> Unit) {
    val startTime = System.currentTimeMillis()
    block()
    val endTime = System.currentTimeMillis()
    println("Time taken: ${endTime - startTime} ms")
}

fun main() {
    measureTime {
        // Code to be measured
        for (i in 1..1000000) {
            // Some operation
        }
    }
}

Inline Functions Example

Explanation — In this example, the measureTime inline function measures the execution time of the provided code block. The function body is copied directly at the call site. As a result, the overhead of calling measureTime is eliminated, and the measurement code is directly embedded within the main function.

4. DSLs with Lambdas — Building Domain-Specific Languages

Photo by Isaac Chou on Unsplash

Example — Leverage Kotlin’s lambda syntax to create domain-specific languages (DSLs) for specific tasks.

class NumberListBuilder {
    private val numbers = mutableListOf<Int>()

    fun number(value: Int) {
        numbers.add(value)
    }

    fun build(): List<Int> {
        return numbers
    }
}

fun buildNumberList(block: NumberListBuilder.() -> Unit): List<Int> {
    val builder = NumberListBuilder()
    builder.block()
    return builder.build()
}

fun main() {
    val numbers = buildNumberList {
        number(10)
        number(20)
        number(30)
    }

    println("Number List: $numbers")
}

DSL Example

Explanation — Here we’re using a DSL to build a list of numbers. Here’s what each part does:

• The NumberListBuilder class is used to construct a list of numbers. It has a private numbers list where numbers are stored.
• The number function within NumberListBuilder is used to add a number to the list.
• The build function within NumberListBuilder returns the final list of numbers.
• The buildNumberList function serves as the entry point to the DSL. It takes a lambda block that can contain calls to number to add numbers to the list.

In the main function, we use the buildNumberList function to create a list of numbers. The DSL syntax with the lambda allows us to easily specify the numbers we want to include in the list.

Please note that this example is intentionally simple to demonstrate the basic concept of DSLs with lambdas. In real-world scenarios, DSLs can be much more complex and powerful, tailored to specific use cases or domains. For Ex. DSL for configuring Logger Settings.

5. Operator Overloading — Adding a Personal Touch

Example — Operator overloading in Kotlin enables customization of operators for user-defined classes.

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

fun main() {
    val point1 = Point(2, 3)
    val point2 = Point(1, 5)
    val sum = point1 + point2
    println("Sum: $sum")
}

Operator Overloading Example

Explanation — The Point class defines the plus operator, allowing instances to be added together like mathematical points.

6. Handling Exceptional Situations with Result

Photo by Count Chris on Unsplash

Example — Kotlin’s Result type provides structured error handling without relying solely on exceptions.

fun divide(a: Int, b: Int): Result<Int> {
    return if (b != 0) {
        Result.success(a / b)
    } else {
        Result.failure(Exception("Division by zero"))
    }
}

fun main() {
    val result = divide(10, 2)
    result.fold(
        onSuccess = { value -> println("Result: $value") },
        onFailure = { error -> println("Error: $error") }
    )
    
    val result2 = divide(10, 0)
    result2.fold(
        onSuccess = { value -> println("Result: $value") },
        onFailure = { error -> println("Error: $error") }
    )
}

Kotlin’s Result Type Example

This article was previously published on proandroiddev.com