Amol Pawar

Kotlin, being a modern and expressive programming language, provides a set of conventions that allow developers to use specific language constructs by defining functions with predefined names. These conventions provide a consistent and intuitive way to work with various language features. In this article, we’ll explore the different aspects of conventions in Kotlin and provide in-depth explanations along with examples.

Kotlin Conventions

As you know, Java has several language features tied to specific classes in the standard library. For example, objects that implement java.lang.Iterable can be used in for loops, and objects that implement java.lang.AutoCloseable can be used in try-with-resources statements. Kotlin has a number of features that work in a similar way, where specific language constructs are implemented by calling functions that you define in your own code. But instead of being tied to specific types, in Kotlin those features are tied to functions with specific names. For example, if your class defines a special method named plus, then, by convention, you can use the + operator on instances of this class. Because of that, in Kotlin we refer to this technique as conventions.

Kotlin uses the principle of conventions, instead of relying on types as Java does, because this allows developers to adapt existing Java classes to the requirements of Kotlin language features. The set of interfaces implemented by a class is fixed, and Kotlin can’t modify an existing class so that it would implement additional interfaces. On the other hand, defining new methods for a class is possible through the mechanism of extension functions. You can define any convention methods as extensions and thereby adapt any existing Java class without modifying its code

BTW, conventions in Kotlin are not limited to operator overloading or extension functions. There are various predefined function names that, when implemented in your class, enable specific language constructs and provide additional functionality. Here are a few examples:

1. iterator: By implementing the iterator function, you enable the usage of your class in for loops, similar to how objects implementing java.lang.Iterable work in Java.
2. invoke: Defining the invoke function allows you to treat instances of your class as function-like objects. This means you can call objects of your class as if they were functions directly, like myObject(parameter).
3. compareTo: If you implement the compareTo function, you can use comparison operators (<, <=, >, >=) on instances of your class, allowing for natural ordering.
4. Destructuring Declarations: Kotlin provides the ability to destructure objects into multiple variables using the component1(), component2(), etc. functions. By implementing these functions in your class, you can use destructuring declarations with instances of your class.

These are just a few examples of Kotlin conventions. By defining functions with specific names in your class, you can harness the power of Kotlin’s language features and make your code more expressive and concise. Kotlin conventions simplify the process of working with common language constructs and operators, promoting code readability and reducing boilerplate. Let’s go through each topic step by step.

Overloading arithmetic operators

As we see earlier, the most straightforward example of the use of conventions in Kotlin is arithmetic operators. In Java, the full set of arithmetic operations can be used only with primitive types, and additionally, the + operator can be used with String values. But these operations could be convenient in other cases as well. For example, if you’re working with numbers through the BigInteger class, it’s more elegant to sum them using + than to call the add method explicitly. To add an element to a collection, you may want to use the += operator. Kotlin allows you to do that, and in the below section, we’ll see how it works.

Overloading binary arithmetic operations

In Kotlin, you can overload binary arithmetic operations by defining functions with the corresponding operator modifier. That means Arithmetic operators, such as +, -, *, /, and %, can be overloaded in Kotlin. To overload an arithmetic operator, you need to define a function with a specific name and annotate it with the operator keyword. Let’s take the example of overloading the plus operator for the Point class.

data class Point(val x: Int, val y: Int)

You can define the plus function within the Point class as follows:

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

Note that the operator keyword is used to declare the plus function. This explicitly indicates that you intend to use the function as an implementation of the + operator convention.

Once you have declared the plus function as an operator, you can use the + sign to sum up instances of the Point class:

val point1 = Point(1, 2)
val point2 = Point(3, 4)
val sum = point1 + point2
println(sum) // Output: Point(x=4, y=6)

The point1 + point2 expression is equivalent to point1.plus(point2). The plus function is called automatically when the + operator is used between two Point instances.

Under the hood, when you use the + operator, the plus function is automatically invoked to perform the addition.

Alternatively, you can define the plus operator function as an extension function outside the Point class:

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

The implementation of the operator function remains the same, but it is now defined as an extension function.

Lists of all the binary operators you can define and the corresponding function names:

You can overload other arithmetic operators in a similar way by defining corresponding functions (minus, times, div, rem, etc.) within your class.

It’s important to note that the precedence of Kotlin operators follows the same rules as the standard numeric types. For example, in an expression like a + b * c, the multiplication (*) will always be executed before the addition (+), regardless of how you have defined those operators, even if you’ve defined those operators yourself. The operators *, /, and % have the same precedence, which is higher than the precedence of the + and — operators

Kotlin operators do not automatically support commutativity, which means you need to define separate operators if you want to swap the order of the operands. For example

operator fun Point.times(scale: Double): Point {
    return Point((x * scale).toInt(), (y * scale).toInt())
}

val p = Point(10, 20)
println(p * 1.5)   // Point(x=15, y=30)

Now suppose If you want users to be able to write 1.5 * p in addition to p * 1.5, you need to define a separate operator for that:

operator fun Double.times(p: Point): Point

Furthermore, The return type of an operator function can also be different from either of the operand types. For example, you can define an operator to create a string by repeating a character a number of times.

operator fun Char.times(count: Int): String {<br>return toString().repeat(count)<br>}<br><br>println('a' * 3)   // aaa

This operator takes a Char as the left operand and an Int as the right operand and has String as the result type. Such combinations of operand and result types are perfectly acceptable.

Note that you can overload operator functions like regular functions: you can define multiple methods with different parameter types for the same method name.

Java Interoperability (Operator Functions and Java)

When it comes to calling Kotlin operator functions from Java, it is straightforward. Since each overloaded operator in Kotlin is defined as a function, you can call them from Java just like regular functions by using the full function name.

For example, let’s say you have a Kotlin class Point with an overloaded plus operator function:

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

In Java, you would call this operator function as a regular function using the fully qualified name:

Point point1 = new Point(1, 2);
Point point2 = new Point(3, 4);
Point sum = point1.plus(point2);

Since Java doesn’t have a specific syntax for operator functions like Kotlin does, you need to call the operator function using the actual function name (plus in this case) instead of the operator symbol (+).

Now when calling Java from Kotlin, you can use the operator syntax for methods that match Kotlin conventions. Kotlin provides syntactic sugar to make code more concise and expressive. For example, if you have a Java class with a method named add and you call it from Kotlin, you can use the + operator instead, as long as the method follows the conventions of the plus operator in Kotlin.

On the other hand, if a Java class defines a method with the desired behavior but with a different name, you can define an extension function in Kotlin with the correct name that delegates to the existing Java method. This allows you to bridge the gap between Kotlin’s operator conventions and Java’s method names.

So, when interacting between Kotlin and Java, Kotlin operator functions can be called from Java as regular functions using their fully qualified names. In the reverse scenario, when calling Java from Kotlin, you can use the operator syntax for methods that adhere to Kotlin’s conventions, and you have the flexibility to define extension functions in Kotlin to map to existing Java methods with different names.

No special operators for bitwise operations

In Kotlin, there are no special operators for bitwise operations on standard number types. Instead, regular functions with infix call syntax are used to perform bitwise operations. You can also define similar functions that work with your own types.

Kotlin provides a set of functions for performing bitwise operations, including:

• shl (Signed shift left): Performs a signed shift left operation.
• shr (Signed shift right): Performs a signed shift right operation.
• ushr (Unsigned shift right): Performs an unsigned (logical) shift right operation.
• and (Bitwise and): Performs a bitwise and operation.
• or (Bitwise or): Performs a bitwise or operation.
• xor (Bitwise xor): Performs a bitwise exclusive or operation.
• inv (Bitwise inversion): Performs a bitwise inversion operation.

Here’s an example demonstrating the use of some of these functions:

println(0x0F and 0xF0)   // Bitwise and operation: 00001111 and 11110000 = 00000000 (result: 0)
println(0x0F or 0xF0)    // Bitwise or operation:  00001111 or  11110000 = 11111111 (result: 255)
println(0x1 shl 4)       // Signed shift left operation: 00000001 shifted left by 4 positions = 00010000 (result: 16)

In the above example, and performs a bitwise and operation between 0x0F (00001111) and 0xF0 (11110000), resulting in 0 (00000000). or performs a bitwise or operation between the same values, resulting in 255 (11111111). shl shifts 0x1 (00000001) left by 4 positions, resulting in 16 (00010000).

It’s important to note that while Kotlin doesn’t provide special operators for bitwise operations, you can use these functions to achieve the desired functionality. Additionally, you can define similar functions for your own types if needed.

Overloading compound assignment operators

In Kotlin, compound assignment operators such as +=, -=, and so on, are supported for certain operations. These operators allow you to modify a variable by performing an operation and assigning the result back to the variable in a single step.

When you define an operator, such as plus, Kotlin automatically supports the corresponding compound assignment operator, such as +=.

However, there can be ambiguity when both the regular operator function and the compound assignment operator function are applicable.

To illustrate, let’s consider the example of the plusAssign function defined for a mutable collection in the Kotlin standard library:

operator fun <T> MutableCollection<T>.plusAssign(element: T) {
    this.add(element)
}

When you use the += operator with a mutable collection, the plusAssign function is called. It adds an element to the collection.

In some cases, there may be ambiguity between using the regular operator or the compound assignment operator. When both the regular operator function (e.g., plus) and the compound assignment operator function (e.g., plusAssign) are applicable, Kotlin needs to decide which one to use.

To resolve this ambiguity, there are a few options:

1. Replace the use of the operator with a regular function call that explicitly states the intention. For example, instead of using +=, you can use the add function directly: collection.add(element).
2. Change a var to a val to make the compound assignment operation inapplicable. If the variable is read-only (val), the compound assignment operator cannot modify its value.
3. Design your classes consistently by providing either the regular operator function or the compound assignment operator function, but not both. If your class is immutable, like the Point class in an earlier example, it\’s best to provide operations that return a new value (e.g., plus). On the other hand, if your class is mutable, like a builder, it\’s best to provide operations like plusAssign that modify the instance in place.

It’s important to note that the Kotlin standard library supports both approaches for collections. The + and - operators always return a new collection. The += and -= operators work on mutable collections by modifying them in place and on read-only collections by returning a modified copy. However, it\’s worth mentioning that += and -= can only be used with a read-only collection if the variable referencing it is declared as a varand not as a val.

val readOnlyList = listOf(1, 2, 3)
var mutableList = mutableListOf(4, 5, 6)

mutableList += readOnlyList
println(mutableList) // Output: [4, 5, 6, 1, 2, 3]

readOnlyList += mutableList // Error: Val cannot be reassigned

In the above example, we have a read-only list readOnlyList and a mutable list mutableList. The += operator can be used to add the elements of readOnlyList to mutableList because mutableList is declared as a var. However, when we try to use += on readOnlyList, it throws an error because readOnlyList is declared as a val and cannot be reassigned.

So, to use += and -= operators on a read-only collection, make sure the variable referencing it is declared as a mutable variable (var). If it is declared as an immutable variable (val), you won\’t be able to modify the collection using these operators.

In Kotlin, when using the += and -= operators on collections, you can provide either individual elements or other collections as operands. The important thing is that the elements or collections you use should have a matching element type with the collection you are modifying.

val numbers = mutableListOf(1, 2, 3)
numbers += 4
println(numbers) // Output: [1, 2, 3, 4]

val list1 = listOf(1, 2, 3)
val list2 = listOf(3, 4, 5)

val combinedList = list1 + list2
println(combinedList) // Output: [1, 2, 3, 3, 4, 5]

It’s important to note that when using collections as operands, the element types should match. In the above example, both list1 and list2 contain integers, so the operations work seamlessly. If the element types don\’t match, such as combining a list of integers with a list of strings, you will encounter a compilation error.

Overloading unary operators

Kotlin allows you to overload unary operators, which are applied to a single value, as in -a. You can overload unary operators such as unary minus (-) and increment/decrement (++ and --) by declaring a function with a predefined name and marking it with the operator modifier.

Let’s start with the unary minus operator. To overload the unary minus operator for a class, you can define a function named unaryMinus without any parameters. This function should negate the coordinates of the object and return it.

data class Point(val x: Int, val y: Int) {
    operator fun unaryMinus(): Point {
        return Point(-x, -y)
    }
}

In the above example, the unaryMinus function negates the coordinates of the Point object and returns a new Point with negated values.

Next, let’s consider the increment and decrement operators (++ and --). When you define the inc and dec functions to overload these operators, the compiler automatically supports the same semantics as for regular number types, including both pre-increment and post-increment operations.

Here’s an example that demonstrates the use of pre-increment and post-increment operators:

data class Counter(var value: Int) {
    operator fun inc(): Counter {
        value++
        return this
    }
    
    operator fun dec(): Counter {
        value--
        return this
    }
}

fun main() {
    var counter = Counter(0)
    println(counter++) // Post-increment: prints the current value (0)
    println(++counter) // Pre-increment: increments and then prints the new value (2)
}

In the above example, the inc function overloads the ++ operator for the Counter class. It increments the value property and returns the updated Counter object. Similarly, the dec function overloads the -- operator for decrementing.

When the increment or decrement operator is used, the semantics depend on whether it is used before or after the operand. The post-increment operator (counter++) evaluates the expression and then increments the value. The pre-increment operator (++counter) increments the value and then evaluates the expression.

Overloading comparison operators

In Kotlin, you can overload comparison operators (such as ==, !=, >, <, >=, <=) for any object, not just for primitive types. This allows for intuitive and concise comparisons.

Equality operators: “equals”

Using the == operator in Kotlin is translated into a call of the equals method, also using the != operator is also translated into a call of equals, with the obvious difference that the result is inverted.

Equality operators (== and !=) can be used with nullable operands because they check for equality to null internally. When using the comparison a == b, it checks whether a is not null and, if it\’s not, calls a.equals(b). If both arguments are null references, the result is true.

To check if two objects refer to the same instance, you can use the identity equals operator (===). It behaves similarly to the == operator in Java and checks if both arguments reference the same object. However, note that the === operator cannot be overloaded.

The equals function is used to implement the equality comparison. It is marked as override because it is defined in the Any class, which is the base class for all objects in Kotlin. You don\’t need to mark it as an operator because the base method in Any is already marked as such, and the operator modifier applies to all methods that implement or override it. It is important to note that equals cannot be implemented as an extension function since the inherited implementation from Any would always take precedence over the extension.

Ordering operators: compareTo

For ordering operators (<, >, <=, >=), Kotlin supports the Comparable interface. The compareTo method defined in this interface can be called by convention, and the usage of comparison operators is translated into calls to compareTo. The return type of compareTo must be Int. For example, the expression p1 < p2 is equivalent to p1.compareTo(p2) < 0. Other comparison operators work in a similar way.

Here’s an example of implementing the compareTo function for a Person class, using address book ordering:

data class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int {
        return if (lastName != other.lastName) {
            lastName.compareTo(other.lastName)
        } else {
            firstName.compareTo(other.firstName)
        }
    }
}

fun main() {
    val person1 = Person("Amol", "Pawar")
    val person2 = Person("Govind", "Rakhonde")

    println(person1 < person2) // true
    println(person1 > person2) // false
}

In the above example, the compareTo function compares Person objects based on their last names first. If the last names are the same, it compares based on their first names. The Comparable interface is implemented to enable comparisons using the concise operator syntax.

It’s important to note that you don’t need to add any extensions to compare Java classes that implement the Comparable interface.

println("abc" < "bac") //true

Kotlin supports the operator syntax for these comparisons out of the box.

Conventions used for collections and ranges

Some of the most common operations for working with collections are getting and setting elements by index, as well as checking whether an element belongs to a collection. All of these operations are supported via operator syntax: To get or set an element by index, you use the syntax a[i] (called the index operator). The in operator can be used to check whether an element is in a collection or range and also to iterate over a collection. You can add those operations for your own classes that act as collections. Let’s now look at the conventions used to support those operations.

Accessing elements by index: “get” and “set”

In Kotlin, you can access and modify values in a map or a custom class using the indexing operator [] and the set function. Let\’s look at how to implement these conventions:

Implementing the get operator:

• To access a value from a map using the indexing operator, you can define the get function in your class.
• The get function takes the key as a parameter and returns the corresponding value.
• You can define the get function with a single parameter of the key type and mark it as operator.
• Inside the get function, you can handle different cases based on the key value and return the appropriate result.

operator fun Point.get(index: Int): Int {
    return when (index) {
        0 -> x
        1 -> y
        else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
    }
}

Implementing the set operator:

• To change the value for a key in a mutable map or a custom class, you can define the set function.
• The set function takes the key and the new value as parameters and updates the corresponding value.
• You can define the set function with two parameters (index and value) and mark it as operator.
• Inside the set function, you can handle different cases based on the index and update the value accordingly.

operator fun MutablePoint.set(index: Int, value: Int) {
    when (index) {
        0 -> x = value
        1 -> y = value
        else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
    }
}

With these implementations, you can use the indexing operator [] on objects of your class to access or modify specific values. For example:

val p = Point(5, 10)

val xCoordinate = p[0] // Accessing the x-coordinate of Point using the indexing operator

p[1] = 20 // Modifying the y-coordinate of Point using the indexing operator

val mutableP = MutablePoint(3, 7)

mutableP[0] = 15 // Modifying the x-coordinate of MutablePoint using the indexing operator

By adhering to the conventions and implementing the get and set functions, you enable the use of square brackets for element access and modification, providing a familiar and intuitive syntax for working with maps or custom collection-like classes.

The “in” convention

In Kotlin, the in operator is used to check whether an object belongs to a collection or range. The corresponding function for the in operator is contains. Here’s how you can use the in operator and implement the contains function:

Using the in operator:

• The object on the right side of the in operator is the object on which the contains method will be called.
• The object on the left side of the in operator becomes the argument passed to the contains method.
• The in operator returns a Boolean value indicating whether the object is present in the collection or range.

val list = listOf(1, 2, 3, 4, 5)
val number = 3
val isInList = number in list // Checking if number is in the list

val range = 1..10
val point = 7
val isInRange = point in range // Checking if point is in the range

Implementing the contains function:

• If you want to use the in operator with custom classes, you need to implement the contains function in your class.
• The contains function takes a single parameter that represents the object being checked for membership.
• Inside the contains function, you can define the logic to determine whether the object is present in the collection or range.
• The function should return a Boolean value indicating the result of the membership check.

data class Rectangle(val left: Int, val top: Int, val right: Int, val bottom: Int) {
    operator fun Rectangle.contains(p: Point): Boolean {
        return p.x in upperLeft.x until lowerRight.x && p.y in upperLeft.y until lowerRight.y
    }
}

val rect = Rectangle(Point(10, 20), Point(50, 50))
println(Point(20, 30) in rect)  // true
println(Point(5, 5) in rect)   // false

In the Rectangle class, the contains function checks if a given Point falls within the range of the rectangle. By using the open range (until), the condition point.x in left until right ensures that the x coordinate of the point is greater than or equal to left but less than right. Similarly, the condition point.y in top until bottom checks if the y coordinate of the point is greater than or equal to top but less than bottom.

In the implementation of Rectangle .contains, you used the until standard library function to build an open range and then you use the in operator on a range to check that a point belongs to it.

An open range is a range that doesn’t include its ending point. For example, if you build a regular (closed) range using 10..20, this range includes all numbers from 10 to 20, including 20. An open range 10 until 20 includes numbers from 10 to 19 but doesn’t include 20. A rectangle class is usually defined in such a way that its bottom and right coordinates aren’t part of the rectangle, so the use of open ranges is appropriate here.

The rangeTo convention

To create a range in Kotlin, you can use the .. syntax. For example, 1..10 represents a range that includes all the numbers from 1 to 10. This syntax is a concise way to call the rangeTo function, which returns a range.

The rangeTo function is defined in the Kotlin standard library and can be called on any comparable element. It has the following signature:

operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T>

This function returns a ClosedRange that allows you to check whether different elements belong to it.

Here’s an example of how you can use the rangeTo function to create a range:

import java.time.LocalDate

fun main() {
    val now = LocalDate.now()
    val futureRange = now.rangeTo(now.plusDays(10))

    for (date in futureRange) {
        println(date)
    }
}

In this example, now.rangeTo(now.plusDays(10)) creates a range of LocalDate objects from the current date (now) to 10 days in the future. The range includes both the starting and ending dates. The rangeTo function isn’t a member of LocalDate but rather is an extension function on Comparable.

When using the rangeTo operator, it\’s recommended to use parentheses to clearly separate the range expression from other operations. For example:

val range = (start..end).step(2)

Additionally, if you want to call a method on a range, make sure to surround the range expression with parentheses to avoid compilation errors. For example:

(0..n).forEach { print(it) }

By using parentheses, you ensure that the forEach method is called on the range expression (0..n).

The “iterator” convention for the “for” loop

In Kotlin, the for loop uses the in operator for iteration. The meaning of the in operator in this context is different from its use with ranges. Here it is used to perform an iteration over a collection or a range.

When you write a for loop like for (x in list) { ... }, it is translated into a call to the iterator() method on the list object. This method returns an iterator on which the hasNext() and next() methods are called repeatedly to iterate over the elements of the collection.

The iterator() method can be defined as an extension function in Kotlin, which explains why you can iterate over a regular Java string. The Kotlin standard library provides an extension function iterator() on CharSequence, which is a superclass of String. It returns a CharIterator that allows iterating over the characters of the string.

operator fun CharSequence.iterator(): CharIterator<br><br>// for (c in "resume sender app") {}

Here’s an example that demonstrates iterating over a custom range type, ClosedRange<LocalDate>:

operator fun ClosedRange<LocalDate>.iterator(): Iterator<LocalDate> =
    object : Iterator<LocalDate> {
        var current = start

        override fun hasNext() = current <= endInclusive

        override fun next() = current.apply { current = plusDays(1) }
    }
}

fun main() {
    val newYear = LocalDate.ofYearDay(2017, 1)
    val daysOff = newYear.minusDays(1)..newYear

    for (dayOff in daysOff) {
        println(dayOff)
    }
}


// OUTPUT
// 2016-12-31
// 2017-01-01 

In this example, the ClosedRange<LocalDate> type is extended with the iterator() method, which returns a custom iterator implementation. The iterator starts from the start date and increments by one day until it reaches the endInclusive date.

The daysOff range represents the day before and New Year day. The for loop then iterates over the dates in the range, printing each day off.

Note how you define the iterator method on a custom range type: you use LocalDate as a type argument. The rangeTo library function, shown in the previous section, returns an instance of ClosedRange, and the iterator extension on ClosedRange allows you to use an instance of the range in a for loop.

By defining the iterator() extension function on a custom range type, you can use an instance of the range in a for loop to perform iteration.

Destructuring declarations and component functions

Destructuring declarations in Kotlin allow you to unpack a single composite value and initialize multiple separate variables with its contents. Here’s how it works:

1. Destructuring declarations look like regular variable declarations, but with multiple variables grouped in parentheses.
2. Under the hood, the principle of conventions is used. To initialize each variable in a destructuring declaration, a function named componentN is called, where N is the position of the variable in the declaration.

For data classes, the compiler automatically generates componentN functions for every property declared in the primary constructor. However, for non-data classes, you need to manually define these functions. Here\’s an example:

class Point(val x: Int, val y: Int) {
    operator fun component1() = x
    operator fun component2() = y
}

In the example above, the Point class has two properties, x and y. The component1() function returns the value of x, and the component2() function returns the value of y. These functions enable destructuring declarations to work with instances of the Point class.

One of the main use cases for destructuring declarations is returning multiple values from a function. You can define a data class to hold the values you want to return and use it as the return type of the function. The destructuring declaration syntax allows you to easily unpack and use the returned values. Let’s take an example of splitting a filename into a name and an extension:

data class NameComponents(val name: String, val extension: String)

fun splitFilename(fullName: String): NameComponents {
    val (name, extension) = fullName.split('.', limit = 2)
    return NameComponents(name, extension)
}

In the splitFilename function, the fullName is split into a list of two elements: the name and the extension. The destructuring declaration val (name, extension) = ... allows us to directly assign these values to the name and extension variables. The function then returns an instance of the NameComponents data class.

Of course, it’s not possible to define an infinite number of such componentN functions so the syntax would work with an arbitrary number of items, but that wouldn’t be useful, either. The standard library allows you to use this syntax to access the first five elements of a container

If you need to return more than two or three values, Kotlin provides the Pair and Triple classes from the standard library. These classes allow you to package multiple values together without defining your own custom class. However, using custom data classes is generally preferred as they provide better clarity about the contained values.

Destructuring declarations and loops

Destructuring declarations can be used not only as top-level statements in functions but also in other places where variable declarations are allowed, such as loops. One useful application is when iterating over entries in a map. Here’s an example that demonstrates this syntax by printing all entries in a given map:

fun printEntries(map: Map<String, String>) {
    for ((key, value) in map) {
        println("$key -> $value")
    }
}

val map = mapOf("resume app" to "Resume Sender App", "kids app" to "ABC123Learn App")
printEntries(map)

// OUTPUT 
// resume app -> Resume Sender App
// kids app -> ABC123Learn App

In this example, the printEntries function takes a Map as input. The for loop uses a destructuring declaration (key, value) to unpack each entry in the map. The key variable will hold the key of the current entry, and the value variable will hold the corresponding value. The body of the loop then prints the key-value pair.

Under the hood, Kotlin provides two conventions for achieving this behavior. First, the Kotlin standard library includes an extension function called iterator on the Map interface, which returns an iterator over the map entries. This allows you to iterate directly over the map in a loop.

Second, the Map.Entry interface, representing a key-value pair in the map, has extension functions component1 and component2. These functions return the key and value, respectively, of the Map.Entry instance. The destructuring declaration in the loop internally calls these functions to assign the key and value to the declared variables.

In essence, the loop using destructuring declarations is equivalent to the following code:

for (entry in map.entries) {
    val key = entry.component1()
    val value = entry.component2()
    // ...
}

This example highlights the significance of extension functions in Kotlin conventions. The extension functions iterator, component1, and component2 enable the concise and readable syntax for iterating over map entries and accessing their key-value pairs.

Conclusion

Conventions in Kotlin provide a powerful way to customize the behavior of language constructs and enhance code readability. By leveraging operator overloading and following function naming conventions, you can create expressive and intuitive APIs. Understanding and utilizing these conventions will help you write clean, concise, and idiomatic Kotlin code.

In this article, we covered various aspects of conventions in Kotlin, including operator overloading conventions for arithmetic operations, comparison operators, indexing, and containment. We also explored Conventions used for collections and ranges and Destructuring declarations.

Remember to practice using conventions in your Kotlin projects to improve code quality and maintainability. Happy coding!

Kotlin offers various powerful features to make code concise and efficient. One such feature is delegation, which allows you to delegate the implementation of properties or functions to another object. This concept of delegation plays a crucial role in achieving code reuse, separation of concerns, and enhancing the readability and maintainability of your code. In this blog, we will explore Kotlin delegation and delve into the details of delegated properties.

Delegated properties allow you to leverage the power of trusted helper objects called delegates. These delegates handle complex tasks, freeing up your properties to focus on their core responsibilities. From database tables to browser sessions and maps, the possibilities are endless.

Join me as we embark on this thrilling journey, exploring the art of delegation and unlocking the true potential of Kotlin delegation properties. Get ready to witness the magic as your properties become extraordinary with just a touch of delegation!

Understanding Kotlin Delegation

Delegation in programming is a design pattern where an object, known as the delegate, is given the responsibility to handle certain tasks or operations on behalf of another object, known as the delegator. The delegator object delegates the work to the delegate object, which performs the task and returns the result to the delegator.

Let’s use a real-life example to understand delegation in Kotlin. Consider a scenario where you have a restaurant with a customer, a waiter, and a chef. The customer wants to order a meal, and the waiter is responsible for taking the order and delivering it to the chef. The chef prepares the meal and hands it back to the waiter, who serves it to the customer.

In this example, the customer is the delegator, and the waiter is the delegate. The customer delegates the task of taking the order and delivering it to the waiter. The waiter performs these tasks on behalf of the customer and then delegates the task of preparing the meal to the chef. Finally, the waiter serves the meal back to the customer.

Let’s take one more example, consider a Car class that needs to perform some operations related to engine management. Instead of implementing those operations directly in the Car class, we can delegate them to an Engine object. This way, the Car class can focus on its core functionality, while the Engine object handles engine-related tasks.

Delegation provides benefits such as modularity, maintainability, and flexibility in designing software systems.

Overview of the Delegation Pattern

The delegation pattern is a design pattern where an object delegates some or all of its responsibilities to another object. Instead of inheriting behavior, an object maintains a reference to another object and forwards method calls to it. This promotes composition over inheritance and provides greater flexibility in reusing and combining behaviors from different objects.

In Kotlin, the delegation pattern is built into the language, making it easy and convenient to implement. With the by keyword, Kotlin allows a class to implement an interface by delegating all of its public members to a specified object. Let’s dive into the details and see how it works.

Basic Usage of Delegation in Kotlin

To understand the basic usage of delegation in Kotlin, let’s consider a simple example. Assume we have an interface called Base with a single function print()

interface Base {
    fun print()
}

Next, we define a class BaseImpl that implements the Base interface. It has a constructor parameter x of type Int and provides an implementation for the print() function.

class BaseImpl(val x: Int) : Base {
    override fun print() {
        println(x)
    }
}

Now, we want to create a class called Derived that also implements the Base interface. Instead of implementing the print() function directly, we can delegate it to an instance of the Base interface. We achieve this by using the by keyword followed by the object reference in the class declaration.

class Derived(b: Base) : Base by b

In this example, the by clause in the class declaration indicates that b will be stored internally in objects of Derived, and the compiler will generate all the methods of Base that forward to b. This means that the print() function in Derived will be automatically delegated to the print() function of the b object.

To see the delegation in action, let’s create an instance of BaseImpl with a value of 10 and pass it to the Derived class. Then, we can call the print() function on the Derived object:

fun main() {
    val b = BaseImpl(10)
    val derived = Derived(b)
    derived.print() // Output: 10
}

When we execute the print() function on the Derived object, it internally delegates the call to the BaseImpl object (b), and thus it prints the value 10.

Overriding Methods in Delegation

In Kotlin, when a class implements an interface by delegation, it can also override methods provided by the delegate object. This allows for customization and adding additional behavior specific to the implementing class.

Let’s extend our previous example to understand method overriding in the delegation. Assume we have an interface Base with two functions: printMessage() and printMessageLine():

interface Base {
    fun printMessage()
    fun printMessageLine()
}

We modify the BaseImpl class to implement the updated Base interface with the two functions printMessage() and printMessageLine():

class BaseImpl(val x: Int) : Base {
    override fun printMessage() {
        println(x)
    }
    override fun printMessageLine() {
        println("$xn")
    }
}

Now, let’s update the Derived class to override the printMessage() function:

class Derived(b: Base) : Base by b {
    override fun printMessage() {
        println("softAai")
    }
}

In this example, the printMessage() function in the Derived class overrides the implementation provided by the delegate object b. When we call printMessage() on an instance of Derived, it will print “softAai” instead of the original implementation.

To test the overridden behavior, we can modify the main() function as follows:

fun main() {
    val b = BaseImpl(10)
    val derived = Derived(b)
    derived.printMessage() // Output: softAai
    derived.printMessageLine() // Output: 10\n
}

When we call the printMessage() function on the Derived object, it invokes the overridden implementation in the Derived class, and it prints “softAai” instead of 10. However, the printMessageLine() function is not overridden in the Derived class, so it delegates the call to the BaseImpl object, which prints the original value 10 followed by a new line.

Property Delegation

In addition to method delegation, Kotlin also supports property delegation. This allows a class to delegate the implementation of properties to another object. Let’s understand how it works.

Assume we have an interface Base with a read-only property message:

interface Base {
    val message: String
}

We modify the BaseImpl class to implement the Base interface with the message property:

class BaseImpl(val x: Int) : Base {
    override val message: String = "BaseImpl: x = $x"
}

Now, let’s update the Derived class to delegate the Base interface and override the message property:

class Derived(b: Base) : Base by b {
    override val message: String = "Message of Derived"
}

In this example, the Derived class delegates the implementation of the Base interface to the b object. However, it overrides the message property and provides its own implementation.

To see the property delegation in action, we can modify the main() function as follows:

fun main() {
    val b = BaseImpl(10)
    val derived = Derived(b)
    println(derived.message) // Output: Message of Derived
}

When we access the message property of the Derived object, it returns the overridden value “Message of Derived” instead of the one in the delegate object b.

Delegated Properties in Kotlin

Delegated properties allow you to delegate the implementation of property accessors (getters and setters) to another object. This means that instead of writing the logic for accessing and setting the property directly in the class, you can delegate it to a separate class.

The general syntax for creating a delegated property is as follows:

class MyClass {
    var myProperty: Type by Delegate()
}

Here, myProperty delegates its getter and setter operations to the Delegate object.

Property Delegates

Property delegates are classes that implement the getValue and optionally setValue functions. These functions are invoked when the delegated property is accessed or modified.

The getValue function is responsible for returning the property value, and setValue is responsible for updating the property value.

Let’s say we have a Delegate class that will handle the logic for accessing and setting a property. The Delegate class should have two methods: getValue() and setValue(). The getValue() method retrieves the current value of the property, and the setValue() method sets a new value for the property. These methods can be defined as either members or extensions of the Delegate class.

Here’s an example of a Delegate class that simply stores the value internally:

class Delegate {
    private var value: Int = 0

    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        // Get the current value of the property
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: Int) {
        // Set a new value for the property
        value = newValue
    }
}

In the above code snippet, the * is used in the parameter of the setValue() and getValue() methods of the Delegate class. This syntax is called a star-projection or star-spread operator.

In Kotlin, the KProperty interface represents a property, and it has a type parameter T that represents the type of property. When you use the star-projection (*) as the type argument (KProperty<*>), it means you are using a wildcard or an unknown type for the property.

In the context of delegated properties, the KProperty<*> parameter represents the property that is being accessed or set. The thisRef parameter represents the instance of the class that owns the property.

By using KProperty<*> with the star-projection, you’re saying that the property can be of any type. It allows you to create a generic Delegate class that can handle properties of different types without explicitly specifying the type.

Also, we defined the operator keyword, which is used to define and overload certain operators for custom types or classes.

Now, let’s create a class Foo with a property p that delegates its accessors to an instance of the Delegate class:

class Foo {
    var p: Int by Delegate()
    var q: String by Delegate()
}

fun main() {
    val foo = Foo()
    foo.p = 42
    foo.q = "softAai"

    println(foo.p) // Output: 42
    println(foo.q) // Output: softAai
}

When you create an instance of Foo, you can access and modify the p property as if it were a regular property. However, behind the scenes, the access and modification operations are delegated to the Delegate class.

Let’s consider one more example for better understanding, just create a simple UpperCaseDelegate that converts a string property to uppercase when accessed:

class UpperCaseDelegate {
    private var value: String = ""

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return value.toUpperCase()
    }
}

To use this delegate:

class MyClass {
    var myProperty: String by UpperCaseDelegate()
}

fun main() {
    val obj = MyClass()
    obj.myProperty = "resume sender app"
    println(obj.myProperty) // Output: RESUME SENDER APP
}

Here, myProperty delegates its getter operation to UpperCaseDelegate, which converts the value to uppercase before returning it.

The “by" keyword

The delegate object is specified after the by keyword and can be any object that satisfies the rules of the convention for property delegates. It’s the delegate object that actually handles the logic for accessing and setting the property.

The by keyword is used in Kotlin to indicate that a property is delegated to another object or class. When you use the by keyword, you are specifying that the implementation of the property’s accessors (getters and setters) will be delegated to a separate delegate object.

By using the by keyword, you make it clear that the property’s implementation is delegated to another object, enhancing code readability and allowing for better separation of concerns.

class Delegate {
    private var value: Int = 0

    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        // Get the current value of the property
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: Int) {
        // Set a new value for the property
        value = newValue
    }
}

class Foo {
    var p: Int by Delegate()
}

In the above example, the p property of the Foo class is delegated to an instance of the Delegate class using the by keyword. The Delegate class provides the implementation for the property’s accessors.

So, when you access or modify the p property of an instance of the Foo class, the property accessors are automatically delegated to the Delegate object. Behind the scenes, the getValue() and setValue() methods of the Delegate class are called to handle the property operations.

Using the by keyword simplifies the syntax and makes it clear that the property behavior is delegated to another object. It promotes code reuse and separates the concerns of the owning class from the delegate class.

Standard Delegates

Kotlin provides several standard delegates in the standard library to address common scenarios. Some examples include:

• lazy: Allows for lazy initialization of properties. The initialization is deferred until the property is accessed for the first time.
• observable: Enables observing property changes by providing a callback function that is triggered whenever the property value is modified.
• vetoable: Allows validation of property values by providing a callback function that can reject value changes based on specific conditions.

Lazy Initialization

Lazy initialization is a technique where you delay the initialization of an object until it is accessed for the first time. This can be useful when the initialization process is resource-intensive and the object might not always be needed during the lifetime of the program.

For example, consider a Person class that lets you access a list of the emails written by a person. The emails are stored in a database and take a long time to access. You want to load the emails on first access to the property and do so only once. Let’s say you have the following function loadEmails, which retrieves the emails from the database:

class Email {
    /*...*/
}

fun loadEmails(person: Person): List<Email> {
    println("Load emails for ${person.name}")
    return listOf(/*...*/ )
}

Here’s how you can implement lazy loading using an additional _emails property that stores null before anything is loaded and the list of emails afterward.

class Person(val name: String) {
    private var _emails: List<Email>? = null

    val emails: List<Email>
        get() {
            if (_emails == null) {
                _emails = loadEmails(this)
            }
            return _emails!!
        }
}

In this implementation, we have a nullable _emails property that acts as a backing property to store the loaded emails. The emails property is the one we access to retrieve the list of emails. In the getter of the emails property, we check if _emails is null. If it is, we initialize it by calling the loadEmails function. We then return the value of _emails, forcibly unwrapping it with !! operator since we know it won’t be null at this point.

While this approach works, it can become cumbersome and error-prone when dealing with multiple lazy properties. Additionally, the implementation is not thread-safe.

To simplify and improve the code, Kotlin provides a built-in solution using the lazy delegate. The lazy function returns an object that has a getValue method, which can be used together with the by keyword to create a delegated property. Here’s how we can use it in our example:

class Person(val name: String) {
    val emails by lazy { loadEmails(this) }
}

With this implementation, the emails property is delegated to the lazy delegate. The lambda expression passed to the lazy function is used to initialize the value of the property when it is accessed for the first time. The lazy delegate ensures that the initialization happens only once, and subsequent accesses to the property will return the cached value.

The lazy function is thread-safe by default, meaning that the initialization is synchronized and can be safely accessed from multiple threads. If you need more control over the thread-safety or want to optimize for a single-threaded environment, you can specify additional options to the lazy function.

Lazy delegate: “by lazy()”

In Kotlin, you can achieve lazy initialization using the lazy delegate provided by the standard library. The lazy function returns an object that has a getValue method, which can be used together with the by keyword to create a delegated property.

The lazy delegate is a built-in feature in Kotlin that allows you to create properties whose values are computed lazily. It provides a concise way to implement lazy initialization without manually managing the initialization state. Here’s how you can use it:

val property: Type by lazy {
    // Initialization code here
    // This block will be executed only once, when the property is accessed for the first time
    // The value of the block will be cached and returned for subsequent accesses
    // Return the computed value
}

Here’s an example to illustrate the usage of lazy initialization with the lazy delegate:

class Example {
    val expensiveProperty: Int by lazy {
        // Expensive computation or initialization
        println("Initializing expensiveProperty...")
        // Return the computed value
        42
    }
}

fun main() {
    val example = Example()
    println("Before accessing expensiveProperty")
    // The initialization code of expensiveProperty is not executed yet
    println("Value of expensiveProperty: ${example.expensiveProperty}")
    // The initialization code of expensiveProperty is executed here
    println("After accessing expensiveProperty")
    println("Value of expensiveProperty: ${example.expensiveProperty}")
    // The cached value is returned without re-initialization
}

OUTPUT

Before accessing expensiveProperty
Initializing expensiveProperty...
Value of expensiveProperty: 42
After accessing expensiveProperty
Value of expensiveProperty: 42

In this example, the expensiveProperty in the Example class is lazily initialized using the lazy delegate. The initialization code block is not executed until the property is accessed for the first time. The computed value (42 in this case) is then cached and returned for subsequent accesses.

When you run the above code, you’ll see that the initialization code block is executed only once, when the property is first accessed. On subsequent accesses, the cached value is returned without re-executing the initialization code.

Lazy initialization with by lazy() simplifies the code by abstracting away the details of managing the initialization state and caching the computed value. It ensures that the property is initialized lazily and provides a convenient way to implement lazy initialization in Kotlin.

Once again here’s an example to illustrate lazy initialization using the lazy delegate:

class Person(val name: String) {
    val emails by lazy { loadEmails(this) }
}

In this example, the Person class has a property called emails, which is lazily initialized using the lazy delegate. The lazy function takes a lambda as an argument, which it will call to initialize the value of the property when it is accessed for the first time.

The benefit of using the lazy delegate is that the initialization logic is encapsulated within it. The value assigned to the emails property will only be computed once, on the first access, and subsequent accesses will return the cached value. This can help improve performance by avoiding unnecessary computations or resource allocations until they are actually needed.

You can think of the emails property as having a backing property that holds the computed value, and the lazy delegate takes care of initializing and caching the value behind the scenes. The delegate ensures that the value is computed lazily, i.e., only when it is first accessed.

Here’s how you would use the Person class:

val person = Person("amol")
println(person.emails) // Initialization happens here, loadEmails() is called
println(person.emails) // Cached value is returned without re-initialization

In this example, the loadEmails() function will only be called on the first access of the emails property. Subsequent accesses will return the cached value without re-initializing it.

The lazy delegate is thread-safe by default, meaning that the initialization is synchronized and can be safely accessed from multiple threads. However, if you know that the class will only be used in a single-threaded environment, you can provide additional options to bypass synchronization and improve performance.

The lazy delegate allows you to achieve lazy initialization of properties. It simplifies the code by encapsulating the initialization logic and ensures that the value is computed only when it is first accessed, providing better performance and resource utilization.

"observable” Delegate

The observable delegate allows you to observe property changes by providing a callback function that is triggered whenever the property value is modified.

Here’s the general syntax for using the observable delegate:

var propertyName: Type by Delegates.observable(initialValue) { property, oldValue, newValue ->
    // Callback function logic
}

Let’s see an example that uses the observable delegate to observe changes in a property:

import kotlin.properties.Delegates

class Person {
    var age: Int by Delegates.observable(25) { property, oldValue, newValue ->
        println("Age changed from $oldValue to $newValue")
    }
}

fun main() {
    val person = Person()
    person.age = 30 // Output: Age changed from 25 to 30
    person.age = 35 // Output: Age changed from 30 to 35
}

In this example, the age property is observed using the observable delegate. Whenever the age property is modified, the callback function is triggered, printing the old value and the new value.

"vetoable” Delegate

The vetoable delegate allows you to validate property values by providing a callback function that can reject value changes based on specific conditions.

Here’s the general syntax for using the vetoable delegate:

var propertyName: Type by Delegates.vetoable(initialValue) { property, oldValue, newValue ->
    // Validation logic
    // Return true to accept the new value, or false to reject it
}

Let’s see an example that uses the vetoable delegate to validate a property value:

import kotlin.properties.Delegates

class Circle {
    var radius: Double by Delegates.vetoable(0.0) { property, oldValue, newValue ->
        newValue >= 0.0 // Only accept positive or zero radius values
    }
}

fun main() {
    val circle = Circle()
    circle.radius = 5.0
    println(circle.radius) // Output: 5.0

    circle.radius = -2.0 // Value rejected due to validation
    println(circle.radius) // Output: 5.0 (unchanged)
}

In this example, the radius property is validated using the vetoable delegate. The callback function checks if the new value is greater than or equal to zero. If the validation condition is not met (e.g., negative radius), the value change is rejected, and the property retains its previous value.

Delegating to another property

Delegating a property to another property means that the getter and setter of one property are implemented by accessing or modifying another property’s value. This delegation can be done for top-level properties, member properties (including extension properties) within the same class, or even member properties of another class.

To delegate a property to another property, you use the :: qualifier followed by the delegate property’s name. Here are a few examples to illustrate how property delegation works:

var topLevelInt: Int = 0

class ClassWithDelegate(val anotherClassInt: Int)

class MyClass(var memberInt: Int, val anotherClassInstance: ClassWithDelegate) {
    var delegatedToMember: Int by this::memberInt
    var delegatedToTopLevel: Int by ::topLevelInt

    val delegatedToAnotherClass: Int by anotherClassInstance::anotherClassInt
}

var MyClass.extDelegated: Int by ::topLevelInt

In the code above, we have different scenarios for property delegation:

1. delegatedToMember is a property within the MyClass class that delegates its getter and setter to the memberInt property of the same class. This means that accessing or modifying delegatedToMember will actually read from or write to memberInt.
2. delegatedToTopLevel is a property within the MyClass class that delegates its getter and setter to the top-level property topLevelInt. So, accessing or modifying delegatedToTopLevel will actually read from or write to topLevelInt.
3. delegatedToAnotherClass is a property within the MyClass class that delegates its getter to the anotherClassInt property of an instance of ClassWithDelegate. This means that accessing delegatedToAnotherClass will read the value of anotherClassInstance.anotherClassInt.
4. extDelegated is an extension property of MyClass that delegates its getter and setter to the top-level property topLevelInt. This allows instances of MyClass to have an additional property extDelegated that shares its value with topLevelInt.

Property delegation can be useful in various scenarios. One common use case is when you want to introduce a new property while maintaining backward compatibility with an existing one. In such cases, you can introduce a new property, annotate the old property with the @Deprecated annotation, and delegate its implementation to the new property. Here’s an example:

class MyClass {
    var newName: Int = 0

    @Deprecated("Use 'newName' instead", ReplaceWith("newName"))
    var oldName: Int by this::newName
}

fun main() {
    val myClass = MyClass()
    // Notification: 'oldName: Int' is deprecated.
    // Use 'newName' instead
    myClass.oldName = 42
    println(myClass.newName) // Output: 42
}

In this example, we have a class MyClass with oldName and newName properties. The oldName property is deprecated and annotated with @Deprecated, indicating that it should not be used anymore. The implementation of oldName is delegated to the newName property using by this::newName. So, accessing or modifying oldName will actually access or modify the newName property.

In the main function, we demonstrate the usage of the deprecated oldName property. When assigning a value to oldName, a deprecation warning is displayed. However, the value is stored in the newName property, which can be accessed correctly.

Overall, delegating properties to other properties provides a powerful mechanism to reuse existing property implementations, introduce backward compatibility, and simplify property access and modification.

Property delegate requirements

Property delegate requirements will be demonstrated for both read-only (val) and mutable (var) properties. Let’s break down the concept of delegated properties for read-only and mutable properties (var) and understand how to provide the necessary operator functions for delegation.

For a read-only property (val), the delegate must provide the getValue() operator function with the following parameters:

• thisRef: This parameter should be the same type as, or a supertype of, the property owner (for extension properties, it should be the type being extended).
• property: This parameter should be of type KProperty<*> or its supertype.
• getValue(): This function must return the same type as the property (or its subtype).

Here’s an example:

class Resource

class Owner {
    val valResource: Resource by ResourceDelegate()
}

class ResourceDelegate {
    operator fun getValue(thisRef: Owner, property: KProperty<*>): Resource {
        return Resource()
    }
}

In this code, we have the Owner class with a read-only property valResource. The delegation is done by using the by keyword and providing an instance of the ResourceDelegate class. The ResourceDelegate class defines the getValue() function, which returns an instance of Resource. The function receives the property owner (thisRef) and the KProperty<*> instance representing the property being delegated.

For a mutable property (var), in addition to the getValue() function, the delegate must provide the setValue() operator function with the following parameters:

• thisRef: This parameter should be the same type as, or a supertype of, the property owner (for extension properties, it should be the type being extended).
• property: This parameter should be of type KProperty<*> or its supertype.
• value: This parameter should be of the same type as the property (or its supertype).

Here’s an example:

class Resource

class Owner {
    var varResource: Resource by ResourceDelegate()
}

class ResourceDelegate(private var resource: Resource = Resource()) {
    operator fun getValue(thisRef: Owner, property: KProperty<*>): Resource {
        return resource
    }

    operator fun setValue(thisRef: Owner, property: KProperty<*>, value: Any?) {
        if (value is Resource) {
            resource = value
        }
    }
}

In this code, we have the Owner class with a mutable property varResource. The ResourceDelegate class now includes the setValue() function, which allows modifying the value of the delegated property. The function receives the property owner (thisRef), the KProperty<*> instance representing the property being delegated, and the new value to be assigned.

You can define the getValue() and setValue() functions as member functions of the delegate class itself or as extension functions. Both functions need to be marked with the operator keyword to enable operator overloading.

Alternatively, you can create delegates as anonymous objects using the interfaces ReadOnlyProperty and ReadWriteProperty from the Kotlin standard library. These interfaces provide the required getValue() and setValue() methods. By using anonymous objects, you can avoid creating separate classes for the delegates. Here’s an example:

fun resourceDelegate(resource: Resource = Resource()): ReadWriteProperty<Any?, Resource> =
    object : ReadWriteProperty<Any?, Resource> {
        private var curValue = resource

        override fun getValue(thisRef: Any?, property: KProperty<*>): Resource = curValue

        override fun setValue(thisRef: Any?, property: KProperty<*>, value: Resource) {
            curValue = value
        }
    }

val readOnlyResource: Resource by resourceDelegate()  // ReadWriteProperty used as a read-only property
var readWriteResource: Resource by resourceDelegate()  // ReadWriteProperty used as a mutable property

In this code, the resourceDelegate() function returns an anonymous object implementing the ReadWriteProperty interface. The ReadWriteProperty interface extends ReadOnlyProperty, so it can be used as a delegate for both read-only and mutable properties. The anonymous object defines the necessary getValue() and setValue() functions.

By using delegated properties and providing the appropriate operator functions, you can create flexible and reusable property delegation patterns in Kotlin.

Storing property values in a map

Another common pattern where delegated properties come into play is objects that have a dynamically defined set of attributes associated with them. Such objects are sometimes called expando objects. in a contact-management system, each person may have some required properties (like name) that are handled in a special way, as well as additional attributes that can vary for each person(youngest child’s birthday, for example).

One way to implement such a system is by using a map to store all the attributes of a person and providing properties that allow access to the information with special handling. Let’s go through the code examples to understand this approach.

First, we have the Person class with a private _attributes map. This map will store the attributes of a person, where the keys are attribute names and the values are attribute values.

class Person {
    private val _attributes = hashMapOf<String, String>()

    fun setAttribute(attrName: String, value: String) {
        _attributes[attrName] = value
    }

    val name: String
        get() = _attributes["name"]!!
}

In this code, we have a set attributefunction that allows adding or updating attributes in the _attributes map. The name property is an example of a required property that is handled in a special way. It retrieves the value of the “name” attribute from the _attributes map.

To create an instance of the Person class and load data into it, we can use a generic API, such as deserialization from JSON, as shown in the example below:

val p = Person()
val data = mapOf("name" to "amol", "company" to "softAai")

for ((attrName, value) in data) {
    p.setAttribute(attrName, value)
}

println(p.name) // Output: amol

Here, we create a new Person instance and provide the data as a map. We iterate over each key-value pair in the data map and call setAttribute to store the attributes in the _attributes map. Finally, we can access the name property, which internally retrieves the value of the “name” attribute from the _attributes map.

Now, instead of manually implementing the property and the _attributes map, we can simplify the code using delegated properties. We can directly delegate the name property to the _attributes map using the by keyword, as shown below:

class Person {
    private val _attributes = hashMapOf<String, String>()

    fun setAttribute(attrName: String, value: String) {
        _attributes[attrName] = value
    

    val name: String by _attributes
}

In this code, we no longer have the explicit getter for the name property. Instead, we use the by keyword to delegate the property to the _attributes map. The standard library provides getValue and setValue extension functions for maps, allowing the property to automatically get and set the values in the map based on the property name.

With the delegated property in place, we can use it just like before:

val p = Person()
val data = mapOf("name" to "amol", "company" to "softAai")

for ((attrName, value) in data) {
    p.setAttribute(attrName, value)
}

println(p.name) // Output: amol

The output remains the same, but now the name property is implemented as a delegated property, simplifying the code and removing the need for an explicit getter.

Delegated properties provide a concise and reusable way to handle dynamically defined attributes in expando objects. By leveraging the by keyword and the standard library extension functions, we can delegate the property access to a map or any other custom logic, making the code more maintainable and flexible.

Translation rules for delegated properties

When using delegated properties in Kotlin, the Kotlin compiler generates auxiliary properties to handle the delegation. These auxiliary properties are used to store the delegate object and manage the getter and setter operations.

Let’s take an example to understand how this works. Consider the following code:

class C {
    var prop: Type by MyDelegate()
}

When the compiler encounters this code, it generates a hidden property called prop$delegate. This hidden property is of the same type as the delegate class (MyDelegate in this case). It is responsible for handling the delegation of the prop property.

The generated code looks like this:

class C {
    private val prop$delegate = MyDelegate()
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

In the generated code, the prop property has a getter and a setter. The getter delegates the getValue() operation to the prop$delegate property, passing the instance of the outer class (this) and the reflection object (this::prop) that represents the property itself. The delegate’s getValue() function is responsible for providing the value of the property.

Similarly, the setter delegates the setValue() operation to the prop$delegate property, passing the instance of the outer class (this), the reflection object (this::prop), and the new value of the property. The delegate’s setValue() function handles the assignment of the new value.

By generating the prop$delegate property and delegating to it, the compiler ensures that the getter and setter operations are correctly handled by the delegate object (MyDelegate).

Optimized cases for delegated properties

When it comes to optimization, the Kotlin compiler can omit the $delegate field in certain cases. Here are the optimized cases for delegated properties:

A referenced property:

class C<Type> {
    private var impl: Type = ...
    var prop: Type by ::impl
}

In this case, the property prop is delegated to another property impl using the by keyword. Since the delegate is a referenced property within the same class, the compiler can optimize the generated code and omit the $delegate field. Instead, the accessors directly delegate to the referenced property impl.

A named object:

object NamedObject {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String = ...
}

val s: String by NamedObject

When using a named object as a delegate, the Kotlin compiler can optimize the code and omit the $delegate field. The accessors directly call the delegate’s getValue function without the need for an intermediate property.

A final val property with a backing field and a default getter in the same module:

val impl: ReadOnlyProperty<Any?, String> = ...

class A {
    val s: String by impl
}

In this case, the delegate impl is a final val property with a backing field and a default getter defined in the same module as the property s. The compiler can optimize the code and omit the $delegate field. The accessors directly delegate to the getValue function of the delegate without the need for an intermediate property.

A constant expression, enum entry, this, or null:

class A {
    operator fun getValue(thisRef: Any?, property: KProperty<*>) ...

    val s by this
}

If the delegate is a constant expression, an enum entry, this, or null, the Kotlin compiler can optimize the code and omit the $delegate field. The accessors directly call the getValue function of the delegate without the need for an intermediate property.

In these optimized cases, the compiler eliminates the need for the $delegate field, which can save memory and provide more efficient property access. The accessors directly invoke the corresponding functions of the delegate, leading to more streamlined code execution.

Note that these optimizations are applied by the Kotlin compiler to improve performance and reduce unnecessary overhead when using delegated properties.

Translation rules when delegating to another property

When delegating to another property, the Kotlin compiler optimizes the code by generating immediate access to the referenced property. This means that the compiler doesn’t generate the $delegate field. This optimization helps save memory and improves performance.

Let’s take a look at the example code:

class C<Type> {
    private var impl: Type = ...
    var prop: Type by ::impl
}

In this case, the property prop is delegated to the property impl using the by keyword. The compiler optimizes the code by directly accessing the impl property within the property accessors of prop. This means that the delegated property’s getValue and setValue operators are skipped, and there is no need for the KProperty reference object.

The compiler generates the following code:

class C<Type> {
    private var impl: Type = ...

    var prop: Type
        get() = impl
        set(value) {
            impl = value
        }

    fun getProp$delegate(): Type = impl // This method is needed only for reflection

As you can see, the accessors for the prop property directly delegate to the impl property. The getValue accessor returns the value of impl, and the setValue accessor assigns the value to impl.

The method getProp$delegate() is also generated, but it is only needed for reflection purposes. It allows reflective access to the delegate object, but it is not used in regular property access.

This optimization avoids the creation of an additional field and reduces the overhead associated with delegated property access. By directly accessing the referenced property, the code becomes more efficient and memory-friendly.

The same optimization principle applies when delegating to another property using this keyword. The compiler generates immediate access to the referenced property without the need for an intermediate field.

Overall, these translation rules improve the performance of delegated properties and eliminate unnecessary memory usage.

What will be the right-hand side of “by"?

In Kotlin, when using delegated properties, the expression to the right of the by keyword can be more than just a new instance creation. It can also be a function call, another property, or any other expression, as long as the value of the expression is an object that provides the getValue and setValue methods with the correct parameter types.

The getValue and setValue methods can be declared directly on the object itself or defined as extension functions. This gives you the flexibility to use existing functions or properties to handle the behavior of your delegated properties.

Here’s an example to demonstrate this concept:

class Example {
    var value: String = "initial"

    // Delegated property using a function call
    var customValue: String by getValueFromFunction()

    // Delegated property using another property
    var anotherValue: String by ::value

    // Delegated property using an extension function
    var computedValue: Int by calculateValue()

    // Extension function providing delegated property behavior
    private fun calculateValue(): ReadWriteProperty<Any?, Int> {
        var storedValue: Int = 0

        return object : ReadWriteProperty<Any?, Int> {
            override fun getValue(thisRef: Any?, property: KProperty<*>): Int {
                // Perform custom logic to compute the value
                return storedValue * 2
            }

            override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
                // Perform custom logic to store the value
                storedValue = value / 2
            }
        }
    }
}

fun getValueFromFunction(): ReadWriteProperty<Any?, String> {
    var storedValue: String = ""

    return object : ReadWriteProperty<Any?, String> {
        override fun getValue(thisRef: Any?, property: KProperty<*>): String {
            return storedValue
        }

        override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
            storedValue = value.toUpperCase()
        }
    }
}

fun main() {
    val example = Example()

    // Using the delegated properties
    example.customValue = "amol"
    println(example.customValue) // Output: AMOL

    example.anotherValue = "softAai"
    println(example.anotherValue) // Output: softAai

    example.computedValue = 5
    println(example.computedValue) // Output: 10
}

In the example above, the customValue property is delegated to the result of a function call getValueFromFunction(), which returns a custom delegate object implementing the ReadWriteProperty interface. The delegate modifies the stored value by converting it to uppercase when setting the value.

The anotherValue property is delegated to the value property using the ::value syntax. Any changes made to anotherValue will be reflected in the value property.

The computedValue property is delegated to the result of the calculateValue() extension function. The extension function provides the delegated property behavior by implementing the ReadWriteProperty interface. In this case, the delegate computes the value by multiplying it by 2 and stores the value by dividing it by 2.

By allowing various expressions on the right-hand side of by and supporting both object-defined and extension-defined getValue and setValue methods, Kotlin enables flexible and customizable behavior for delegated properties.

Providing a delegate

The provideDelegate operator allows you to extend the logic for creating the object to which the property implementation is delegated. If the object used on the right-hand side of the by keyword defines provideDelegate as a member or extension function, that function will be called to create the property delegate instance.

One use case of provideDelegate is to perform additional checks or actions during the initialization of the property delegate. For example, you can check the consistency of the property before binding it.

Here’s an example that demonstrates how to use provideDelegate:

class ResourceDelegate<T> : ReadOnlyProperty<MyUI, T> {
    override fun getValue(thisRef: MyUI, property: KProperty<*>): T { ... }
}

class ResourceLoader<T>(id: ResourceID<T>) {
    operator fun provideDelegate(
            thisRef: MyUI,
            prop: KProperty<*>
    ): ReadOnlyProperty<MyUI, T> {
        checkProperty(thisRef, prop.name)
        // create delegate
        return ResourceDelegate()
    }

    private fun checkProperty(thisRef: MyUI, name: String) { ... }
}

class MyUI {
    fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }

    val image by bindResource(ResourceID.image_id)
    val text by bindResource(ResourceID.text_id)
}

In this example, the ResourceLoader class defines the provideDelegate function. This function is called for each property during the creation of an instance of MyUI. It performs the necessary validation or checks before creating the property delegate.

Without the provideDelegate functionality, you would need to pass the property name explicitly to achieve the same functionality, which could be less convenient.

The provideDelegate method has the same parameters as the getValue function:

• thisRef must be the same type as, or a supertype of, the property owner (for extension properties, it should be the type being extended).
• property must be of type KProperty<*> or its supertype.

The provideDelegate method is responsible for creating and returning the property delegate instance that will handle the property access.

In the generated code, when provideDelegate is present, it is called to initialize the auxiliary prop$delegate property. Compare the generated code for the property declaration val prop: Type by MyDelegate() with the generated code when provideDelegate is available:

class C {
    var prop: Type by MyDelegate()
}

// Generated code with `provideDelegate` function:
class C {
    // Calling `provideDelegate` to create the additional `delegate` property
    private val prop$delegate = MyDelegate().provideDelegate(this, this::prop)
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

It’s important to note that the provideDelegate method only affects the creation of the auxiliary property (prop$delegate) and does not impact the generated code for the getter or the setter of the delegated property.

You can also use the PropertyDelegateProvider interface from the standard library to create delegate providers without creating new classes. Here’s an example:

val provider = PropertyDelegateProvider { thisRef: Any?, property ->
    ReadOnlyProperty<Any?, Int> { _, property -> 42 }
}
val delegate: Int by provider

In this case, the PropertyDelegateProvider creates a delegate provider using a lambda expression. The lambda receives the thisRef (property owner) and property information and returns a property delegate instance.

Delegation in Android Applications

Kotlin delegation and delegated properties can be useful in Android applications to simplify code, separation of concerns, and provide flexibility in handling certain tasks. Here are a few examples of how delegation can be used in Android applications:

1. Shared Preferences Delegation

Android applications often need to store and retrieve key-value pairs using SharedPreferences. Delegation can be used to simplify the code for accessing SharedPreferences. For example:

class SettingsManager(context: Context) {
    private val preferences: SharedPreferences by lazy {
        context.getSharedPreferences("settings", Context.MODE_PRIVATE)
    }

    var isNotificationsEnabled: Boolean by BooleanPreferenceDelegate(
        preferences, "notifications_enabled", true
    )
}

class BooleanPreferenceDelegate(
    private val preferences: SharedPreferences,
    private val key: String,
    private val defaultValue: Boolean
) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): Boolean {
        return preferences.getBoolean(key, defaultValue)
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Boolean) {
        preferences.edit { putBoolean(key, value) }
    }
}

In this example, the SettingsManager class uses delegation to handle the isNotificationsEnabled property, which is backed by a shared preference value. The BooleanPreferenceDelegate class implements the delegated property behavior.

2. Dependency Injection with Delegation:

Dependency injection frameworks like Dagger can benefit from delegation to simplify the injection process. By using a delegated property, you can abstract away the complexity of dependency resolution. Here’s a simplified example:

class MyActivity : AppCompatActivity() {
    private val myDependency: MyDependency by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Use myDependency
    }
}

interface Injectable {
    fun injectDependencies()
}

class MyDependency {
    // Dependency implementation
}

inline fun <reified T : Injectable> AppCompatActivity.inject(): Lazy<T> {
    return lazy {
        val injectable = T::class.java.newInstance()
        injectable.injectDependencies()
        injectable
    }
}

In this example, the MyActivity class uses delegation to lazily inject the MyDependency instance. The inject function provides the delegation logic for dependency injection, making it easy to reuse across different activities.

These are just a few examples of how delegation and delegated properties can be used in Android applications. They demonstrate how delegation can simplify code, improve code organization, and provide flexibility in various scenarios.

Conclusion

Kotlin delegation and delegated properties provide an elegant and efficient way to handle code reuse and separation of concerns. By understanding the concept of delegation and utilizing delegated properties, you can write cleaner, more maintainable code in your Kotlin projects. Whether you’re developing Android applications or working on other Kotlin projects, delegation is a powerful tool to enhance your codebase. Start exploring the possibilities of delegation in Kotlin and unlock the benefits it brings to your software development journey.

Kotlin provides several special types that serve specific purposes, including types such as Any, Unit, and Nothing. Understanding these types and their characteristics is crucial for writing clean and concise Kotlin code. In this article, we will explore the features and use cases of each type, along with relevant examples.

Any: The Root Type

In Kotlin, the Any type serves as the root of the type hierarchy, similar to how the Object class is the root of the class hierarchy in Java. However, there are some differences between the two.

In Java, the Object class is a supertype of all reference types, but it does not include primitive types. This means that if you want to use a primitive type where an Object is required, you need to use wrapper types like Integer to represent the primitive value.

On the other hand, in Kotlin, the Any type is a supertype of all types, including primitive types such as Int. This means that you can assign a value of a primitive type directly to a variable of type Any, and automatic boxing will be performed.

For example:

val answer: Any = 42

Note that the Any type is non-nullable, so a variable of type Any cannot hold a null value. If you need a variable that can hold any value, including null, you need to use the Any? type.

Internally, the Any type in Kotlin corresponds to java.lang.Object. When you use Object in Java method parameters or return types, it is seen as Any in Kotlin. However, it is considered a platform type because its nullability is unknown. When a Kotlin function uses Any, it is compiled to Object in the Java bytecode.

The Any type inherits three methods from Object: toString(), equals(), and hashCode(). These methods are available in all Kotlin classes. However, other methods are defined on java.lang.Object, such as wait() and notify(), are not directly available on Any. If you need to call these methods, you can manually cast the value to java.lang.Object.

Key Characteristics of Any Type

1. Type Safety: Although Any type allows flexibility in holding values of different types, Kotlin’s type system ensures type safety. The compiler performs type checks and prevents incompatible operations on Any-typed variables. This ensures that operations specific to a particular type are only performed when the type is guaranteed at compile-time.
2. Common Functions and Properties: Any supports common functions and properties provided by Kotlin’s standard library, such as toString(), equals(), and hashCode(). These functions are available on all classes in Kotlin since they implicitly inherit from Any.
3. Smart Casting: Kotlin’s smart casting mechanism enables the automatic casting of Any-typed variables to more specific types. If the compiler can guarantee the correctness at compile-time, the variable is automatically cast to the more specific type. This allows developers to access type-specific functions and properties without explicit casting.

Practical Use Cases and Examples

Let’s explore some practical use cases of the Any type:

1. Writing Generic Functions: The Any type is often used in the context of writing generic functions that can operate on values of any type. This allows developers to create reusable code that can handle a wide range of input types.

fun <T> printValue(value: T) {
    println("The value is: $value")
}

val stringValue: String = "softAai Apps!"
val intValue: Int = 42

printValue(stringValue) // The value is: softAai Apps!
printValue(intValue)    // The value is: 42

2. Working with Heterogeneous Collections: Any type is useful when dealing with collections that can contain elements of different types. This allows developers to create collections that can hold values of various types, providing flexibility in scenarios where the types are not known in advance.

val heterogeneousList: List<Any> = listOf("softAai", 42, true)

for (element in heterogeneousList) {
    when (element) {
        is String -> println("String: $element")
        is Int -> println("Int: $element")
        is Boolean -> println("Boolean: $element")
        else -> println("Unknown type")
    }
}

In the above example, the heterogeneousList contains elements of different types (String, Int, Boolean). By using Any type in the list’s declaration, we can store and process elements of different types in a single collection.

3. Working with Unknown Types: In some scenarios, the specific type of a value may not be known at compile time. In such cases, the Any type allows us to handle values dynamically and perform type-specific operations using smart casting.

fun printLength(any: Any) {
    if (any is String) {
        println("Length: ${any.length}") // Smart cast: any is automatically cast to String
    } else {
        println("Unknown type")
    }
}

val stringValue: String = "softAai Apps!"
val intValue: Int = 42

printLength(stringValue) // Length: 13
printLength(intValue)    // Unknown type

In the above example, the printLength() function takes an Any-typed parameter. If the parameter is a String, its length is printed using smart casting. This allows us to perform String-specific operations on the variable without the need for explicit casting.

Kotlin’s Any type provides flexibility in holding values of any type while ensuring type safety. It allows developers to write generic functions, work with heterogeneous collections, and handle unknown types dynamically. By leveraging the features of Any type, developers can create more flexible and reusable code.

Unit: Kotlin’s ‘’void’’

In Kotlin, the Unit type serves a similar purpose as the void type in Java. It is used as the return type of a function that does not have any meaningful value to return. Syntactically, you can explicitly declare the return type as Unit or simply omit the type declaration, and the function will be treated as returning Unit.

fun f(): Unit { ... }
// or
fun f() { ... }

In most cases, you won’t notice much of a difference between void and Unit. When a Kotlin function has the Unit return type and does not override a generic function, it is compiled to a regular void function under the hood. If you override it from Java, the Java function simply needs to return void.

However, what distinguishes Kotlin’s Unit from Java’s void is that Unit is a full-fledged type and can be used as a type argument. In Kotlin, Unit is a type with a single value, also called Unit. This is useful when you override a function that returns a generic parameter and want it to return a value of the Unit type.

For example, suppose you have an interface Processor<T> that requires a process() function to return a value of type T. You can implement it with Unit as the type argument:

interface Processor<T> {
    fun process(): T
}

class NoResultProcessor : Processor<Unit> {
    override fun process() {
        // do stuff
    }
}

In this case, the process() function in NoResultProcessor returns Unit, which is a valid value for the Unit type. You don’t need to write an explicit return statement because the compiler adds return Unit implicitly.

In Java, the options for achieving a similar behavior are not as elegant. One option is to use separate interfaces, such as Callable and Runnable, to represent functions that do or do not return a value. Another option is to use the special java.lang.Void type as the type parameter. However, in the latter case, you still need to include an explicit return null; statement to return the only possible value that matches the Void type.

The reason Kotlin chose the name Unit instead of Void is because the name Unit is traditionally used in functional languages to mean “only one instance.” This aligns with the nature of Kotlin’s Unit type, which represents a single value. Using the name Void could be confusing, especially since Kotlin already has a distinct type called Nothing that serves a different purpose. Having two types named Void and Nothing would be confusing due to the similarities in meaning and function.

Key Characteristics of Unit Type

1. Return Type: Unit is commonly used as a return type for functions that do not produce a result or return a meaningful value. When a function’s return type is Unit, the return keyword becomes optional.
2. Functionality: The Unit type itself does not have any special functions or properties associated with it. It is simply a marker type to indicate the absence of a value. However, functions returning Unit can still have side effects, such as printing to the console or modifying state.
3. Single Value: Unit has only one value, also named Unit. It represents the absence of any specific value. Since it signifies nothing meaningful, there is no need to create instances of Unit.

Practical Use Cases and Examples

Let’s explore some practical use cases of the Unit type:

1. Functions with Side Effects: Functions that perform side effects, such as printing or modifying state, often have a return type of Unit. This conveys that the function doesn’t produce a meaningful result but performs actions that affect the program’s state.

fun greet(name: String): Unit {
    println("Hello, $name!")
}

greet("softAai") // Hello, softAai!

In the above example, the greet() function takes a name parameter and prints a greeting message. The return type is Unit, indicating that the function doesn’t return a specific value.

2. Discarding Function Results: Sometimes, we may invoke a function solely for its side effects and not require its return value. In such cases, the Unit type can be used to explicitly indicate the disregard for the result.

fun logMessage(message: String): Unit {
    // Perform logging
}

val result: Unit = logMessage("An important log message")

In the above example, the logMessage() function logs a message but doesn’t return any meaningful result. The result variable is assigned the value of Unit, indicating that the return value is disregarded.

3. Interoperability with Java: When working with Java libraries or frameworks that have void-returning methods, Kotlin’s Unit type can be used as a compatible return type. This allows seamless integration between Kotlin and Java codebases.

// Kotlin function calling a Java method with void return type
fun callJavaMethod(): Unit {
    JavaClass.someVoidMethod()
}

In the above example, the callJavaMethod() function invokes a Java method, which returns void. By specifying the return type as Unit, Kotlin can seamlessly interact with the Java codebase.

Kotlin’s Unit type represents the absence of a meaningful value and is commonly used as a return type for functions without specific results. It allows developers to indicate side effects, discard function results and enable seamless interoperability with Java code. By utilizing the Unit type effectively, developers can write expressive and concise code that conveys the absence of a meaningful value where necessary.

Nothing: “This function never returns”

In Kotlin, the Nothing type is used to represent functions that never return normally. It is a special return type that indicates that the function does not complete successfully and does not produce any value.

One common use case for the Nothing type is in functions that intentionally fail or throw an exception to indicate an error or an unexpected condition. For example, a testing library may have a function called fail that throws an exception to fail a test with a specified message:

fun fail(message: String): Nothing {
    throw IllegalStateException(message)
}

fail("Error occurred") // Throws an IllegalStateException with the specified message

In this example, the fail function has a return type of Nothing. Since the function always throws an exception, it never completes normally, and the return type Nothing reflects that.

The Nothing type itself does not have any values. It is used solely as a function return type or as a type argument for a type parameter that is used as a generic function return type. In other contexts, such as declaring a variable, using Nothing doesn’t make sense because there are no values of that type.

One useful feature of functions returning Nothing is that they can be used on the right side of the Elvis operator (?:) for precondition checking. The compiler knows that a function with the Nothing return type never completes normally, so it can infer the non-null type of the variable being assigned.

val address = company.address ?: fail("No address")
println(address.city)

In this example, if company.address is null, the fail function is called, which throws an exception. Since the fail function has a return type of Nothing, the compiler infers that the type of address is non-null. This allows you to safely access address.city without null checks.

Key Characteristics of Nothing Type

1. Absence of Instances: Similar to the Unit type, there are no instances of the Nothing type. It is used purely as a type to indicate situations where a value cannot exist.
2. Subtype Relationship: Nothing is a subtype of all other Kotlin types, which means it can be used in place of any type when necessary. This allows developers to express that a particular branch of code is unreachable or throws an exception.
3. Type Inference: The Nothing type also plays a role in Kotlin’s type inference system. If a function has a return type of Nothing, the compiler can infer the type of any variables or expressions within that function to be Nothing as well.

Practical Use Cases and Examples

Let’s explore some practical use cases of the Nothing type:

1. Throwing Exceptions: The Nothing type is often used when a function is intended to throw an exception and never complete normally. By specifying the return type as Nothing, we explicitly indicate that the function will always throw an exception and never return a value.

fun throwError(): Nothing {
    throw IllegalArgumentException("An error occurred")
}

In the above example, the throwError() function explicitly specifies a return type of Nothing. It throws an exception, ensuring that the function never returns normally.

2. Unreachable Code: The Nothing type is useful in situations where a specific branch of code should be unreachable due to a condition or assertion. By assigning a value of type Nothing to a variable or using it as the return type, the compiler can ensure that the unreachable code is detected.

fun processStatus(status: Int): String {
    return when (status) {
        200 -> "OK"
        404 -> "Not Found"
        else -> error("Invalid status code: $status") // Unreachable code
    }
}

fun error(message: String): Nothing {
    throw RuntimeException(message)
}

fun main() {
    val statusCode = 200
    val response = processStatus(statusCode)
    println("Response: $response")
}

In the above example, the error function takes a message parameter of type String and has a return type of Nothing.

The error function throws a RuntimeException with the specified error message. This means that when the error function is called, it will always throw an exception and never return normally. By specifying a return type of Nothing, it signals to the compiler that this function does not have a normal return path.

In the processStatus function, the error function is used within the else branch of the when expression. If the else branch is reached, the error function is called with the appropriate error message, indicating an invalid status code.

The main function remains the same, where a sample statusCode of 200 is passed to the processStatus function, and the resulting response is printed to the console.

When you run this code, if the else branch is reached (which should not happen under normal circumstances), the error function will throw a RuntimeException with the error message “Invalid status code: <status>”.

3. Type Inference and Control Flow Analysis: The Nothing type aids Kotlin’s type inference system and control flow analysis. If the compiler determines that a certain branch of code results in a non-terminating function call or throws an exception, it can infer the type of variables within that branch to be Nothing.

fun infiniteLoop(): Nothing {
    while (true) {
        // Perform some operations
    }
}

val result = if (condition) 42 else infiniteLoop() // The type of 'result' is Nothing

In the above example, the infiniteLoop() function has a return type of Nothing because it never terminates. The compiler infers that the type of the variable ‘result’ is also Nothing because one branch of the conditional expression results in an infinite loop.

Kotlin’s Nothing type represents a value that never exists and is used in scenarios where a function cannot return normally or a value cannot be assigned. It is commonly used to handle exceptional scenarios and indicate unreachable code. By leveraging the Nothing type effectively, developers can enhance the reliability and expressiveness of their Kotlin programs.

Summary

To summarize, Kotlin’s Any, Unit, and Nothing types provide distinct functionalities and play crucial roles in different scenarios. The Any type allows variables to hold values of any type, providing flexibility and enabling generic programming. The Unit type represents the absence of a meaningful value and is commonly used as a return type for functions without specific results. Lastly, the Nothing type is used to handle exceptional situations, indicate unreachable code, or represent values that never exist.

By understanding the characteristics and use cases of these types, developers can write more expressive, type-safe, and concise code in Kotlin. Leveraging the flexibility of Any, expressing the absence of a value with Unit, and handling exceptional scenarios using Nothing, Kotlin developers can build robust and reliable applications.

Kotlin, a modern programming language for the JVM, comes with a robust and expressive set of collection classes and functions. Kotlin collections provide a seamless way to work with data, enabling efficient data manipulation, transformation, and filtering. Whether you’re a beginner or an experienced Kotlin developer, understanding the various collection types, operations, and best practices is essential. In this article, we will explore Kotlin collections in depth, covering all aspects and providing practical examples to solidify your understanding.

What are Kotlin Collections?

In Kotlin, collections refer to data structures that can hold multiple elements. They provide a way to store, retrieve, and manipulate groups of related objects. Kotlin provides a rich set of collection classes and interfaces in its standard library, making it convenient to work with collections in various scenarios.

Here are some commonly used collection interfaces in Kotlin:

1. Collection: The root interface for read-only collections. It provides methods for accessing elements, such as iteration, size checking, and element presence checks.
2. MutableCollection: Extends the Collection interface and adds methods for modifying the collection, such as adding and removing elements.
3. List: Represents an ordered collection of elements. Elements can be accessed by their indices. Kotlin provides ArrayList and LinkedList as implementations of the List interface.
4. MutableList: Extends the List interface and adds methods for modifying the list, such as adding, removing, and modifying elements.
5. Set: Represents a collection of unique elements, with no defined order. Kotlin provides HashSet and LinkedHashSet as implementations of the Set interface.
6. MutableSet: Extends the Set interface and adds methods for modifying the set.
7. Map: Represents a collection of key-value pairs. Each key in the map is unique, and you can retrieve the corresponding value using the key. Kotlin provides HashMap and LinkedHashMap as implementations of the Map interface.
8. MutableMap: Extends the Map interface and adds methods for modifying the map.

These are just a few examples of collection interfaces in Kotlin. The standard library also includes other collection interfaces and their corresponding implementations, such as SortedSet, SortedMap, and Queue, along with various utility functions and extension functions to work with collections more efficiently.

Collections in Kotlin provide a convenient way to handle groups of data and perform common operations like filtering, mapping, sorting, and more. They play a vital role in many Kotlin applications and can greatly simplify data manipulation tasks.

Read-Only and Mutable Collections

Kotlin collection design separates interfaces for accessing and modifying data in collections. This design distinguishes between read-only and mutable interfaces, providing clarity and control over how collections are used and modified.

The kotlin.collections.Collection interface is used for accessing data in a collection. It allows you to iterate over the elements, obtain the size, check for the presence of specific elements, and perform other read operations. However, it does not provide methods for adding or removing elements.

fun printCollection(collection: Collection<Int>) {
    for (element in collection) {
        println(element)
    }
}

val myList = listOf(1, 2, 3)
printCollection(myList) // This works fine

To modify the data in a collection, you should use the kotlin.collections.MutableCollection interface. It extends the Collection interface and adds methods for adding and removing elements, clearing the collection, and other modification operations.

fun addToCollection(collection: MutableCollection<Int>, element: Int) {
    collection.add(element)
}

val myMutableList = mutableListOf(1, 2, 3)
addToCollection(myMutableList, 4) // This modifies the collection

Creating a defensive copy

By using read-only interfaces (Collection) throughout your code, you convey that the collection won’t be modified. If a function accepts a Collection parameter, you can be confident that it only reads data from the collection. On the other hand, when a function expects a MutableCollection, it indicates that the collection will be modified. If you have a collection that is part of your component’s internal state and needs to be passed to a function requiring a MutableCollection, you may need to create a defensive copy of that collection to ensure its integrity.

fun modifyCollection(collection: MutableCollection<Int>) {
    val defensiveCopy = collection.toList()
    // Perform modifications on the defensiveCopy
    // ...
}

val originalList = mutableListOf(1, 2, 3)
modifyCollection(originalList) // The original list remains unchanged

In this example, we have a function modifyCollection that takes a mutable collection as a parameter. However, if the collection is part of your component’s internal state and you want to ensure its integrity, you can create a defensive copy of the collection before passing it to the function.

By calling toList() on the original collection, we create a new read-only list defensiveCopy that contains the same elements. The modifyCollection function can then perform any modifications on the defensive copy without affecting the original collection.

This approach allows you to protect the original collection from unintended modifications, especially when it is part of the component’s internal state or when you want to ensure its immutability in certain scenarios.

Immutable Collections

Kotlin offers a variety of immutable collection types, such as lists, sets, and maps, that cannot be modified once created. These collections guarantee thread safety and immutability, ensuring data integrity in multi-threaded scenarios. Let’s see some examples:

val numbers = listOf(1, 2, 3, 4, 5)  // Immutable list
val setOfColors = setOf("red", "green", "blue")  // Immutable set
val mapOfUsers = mapOf(1 to "Alice", 2 to "Bob", 3 to "Charlie")  // Immutable map