Operator overloading

Kotlin is a language that adapts to your way of programming or code writing. Kotlin allows you to define your custom implementations of operators and allows making your code cleaner and more readable.

In this topic, you will learn how to define your own implementations of operators on your data types.

Operator overloading

Kotlin allows you to define your own operators on certain types. These operators have predefined symbolic representation, like "+" or "+=", and precedence. To define our custom operator, we must meet these requirements:

• Provide a member function or an extension function with a specific name for the corresponding type.

• This type becomes the left-hand side type for binary operations and the argument type for the unary ones.

To customize an operator, we should mark the function with the operator modifier.

operator fun String.unaryMinus() = this.reversed()

fun main() {
    val name = "Kotlin"
    println(-name) // niltoK
}

Also, you can combine operator with the infix modifier.

infix operator fun String.times(n: Int) = this.repeat(n)

fun main() {
    val s = "Kotlin"
    println(s * 3) //KotlinKotlinKotlin
}

Unary operations

These are functions that generally have no parameters.

Unary prefix operators

Increments and decrements

operator fun Pair<Int, Int>.unaryMinus() = Pair(-first, -second)
operator fun Pair<Int, Int>.inc() = Pair(first + 1, second + 1)

fun main() {
    var p = Pair(1, 2)
    println(-p) // (-1, -2)
    println(++p) // (2, 3)
}

Binary operations

These are functions that generally have two parameters.

Arithmetic operators

operator fun Pair<Int, Int>.plus(other: Pair<Int, Int>) = 
    Pair(first + other.first, second + other.second)


fun main() {
    var point1 = Pair(1, 2)
    var point2 = Pair(3, 4)
    println(point1 + point2) // (4, 6)
}

in operator

For in and !in, the procedure is the same, but the order of arguments is reversed.

operator fun Pair<Int, Int>.contains(n: Int) = n in first..second

fun main() {
    var point1 = Pair(1, 2)
    println(1 in point1) // true
}

Indexed access operator

Square brackets [] are translated to calls to get and set.

operator fun Pair<Int, Int>.get(n: Int) = when (n) {
    0 -> first
    1 -> second
    else -> throw IndexOutOfBoundsException()
}

fun main() {
    var point1 = Pair(1, 2)
    println(point1[0]) // 1
    println(point1[1]) // 2
}

invoke operator

Parentheses with parameters are translated to calls to invoke.

operator fun Pair<Int, Int>.invoke(newLine: Boolean) {
    print("($first, $second)")
    if (newLine) println()
}

fun main() {
    var point1 = Pair(1, 2)
    point1(true) // [1, 2]


}

Augmented assignments

They perform the same operations as binary methods but assign the result to the same object.

operator fun StringBuilder.plusAssign(other: String) {
    this.append(other)
}

fun main() {
    val name = StringBuilder("Kotlin")
    name += " is awesome"
    println(name) // Kotlin is awesome
}

Equality and inequality operators

These operators only work with the function equals(other: Any?) implementation of a class or type.

class Point(val x: Int, val y: Int) {
    override fun equals(other: Any?): Boolean {
        if (other is Point) {
            return other.x == x && other.y == y
        }
        return false
    }
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(1, 2)
    println(p1 == p2) // true
}

Comparison operators

These operators only work with the function compareTo() implementation of a class or type.

class Point(val x: Int, val y: Int) : Comparable<Point> {
    override fun compareTo(other: Point): Int {
        return if (x == other.x) y.compareTo(other.y) else x.compareTo(other.x)
    }
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(1, 2)
    println(p1 < p2) // false
    println(p1 <= p2) // true
}

Conclusion

Operator overloading is a powerful tool for making our code more readable and maintainable. To use it, you must take into account the indicated requirements. It will help you take your code to another level of quality in managing your types and methods.

Now is the time to check what you have learned with some tasks. Let's go!