Kotlin Data Classes and Smart Casts

Introduction

Kotlin is a language that is built by the Jetbrains team and opensource contributors. The following are the goals that this language helps us achieve (not full set, for more details please visit kotlinlang.org

• Modern, concise and safe programming language
• A productive way to write server‑side applications (still using the frameworks that target JVM)
• Cross-platform layer for native applications
• Big, friendly and helpful community

Kotlin Data Classes

Below I am giving some of the kotlin snippets and short descriptions on what they can perform. Keep in mind that kotlin achieves very concise code

data class Person (val name:String, val age: Int){

   

}

fun getPeople(): List<Person> {

    return listOf(Person("Alice", 29), Person("Bob", 31))

}

fun comparePeople(): Boolean {

    val p1 = Person("Alice", 29)

    val p2 = Person("Alice", 29)

    return p1 == p2  // should be true

}

In the snippet above, we are using a feature called as Data Classes  from Kotlin which help in getting automatic getters, setters, equals and hashcode and also providing the developer flexible option in overriding one if required.

Smart Casts

I have been like why should you use a cast operator after checking if the object is an instance of an Artifact (Interface / class etc..) , because there will be too much of a cast going on whenever we try to use the values, most like ((x)a).field

The kotlin team has a smart cast that enables the developer to use the variable on the target type after a type check using is

Sample Code

In the below code snippet, everything is concise at its best.

We have an interface (Marker interface) just the keyword and the name,

We have classes with keyword, name and constructor arguments.

The input is checked as Num  if so we directly call the property value without an explicit cast, the compiler and the IDE help us achieve this with ease.

Similar logic applies for the is Sum where we check if the input is of type Sum if so we directly perform the operation on the properties rather than a cast. This is very helpful to the developer in not needing to use a cast or wait for exceptions at runtime

fun eval(expr: Expr): Int =

        when (expr) {

            is Num -> expr.value

            is Sum -> (eval(expr.left)+eval(expr.right))

            else -> throw IllegalArgumentException("Unknown expression")

        }

interface Expr

class Num(val value: Int) : Expr

class Sum(val left: Expr, val right: Expr) : Expr