Operator Overloading in Kotlin

What is operator overloading?

Operator overloading has its root in the language C++. It means, that you can define the behavior if an operator (e.g. +, -, *, …) is applied to your type. (Wikipedia)

In C++ this looks like the following.

Given we have a class Vector containing a x and a y field as coordinates. We can define the operator plus + as follows:

    Vector operator + (Vector const &obj) { 
         Vector res; 
         res.x = x + obj.x; 
         res.y = y + obj.y; 
         return res; 

In my opinion this technique has been forgotten since the days of C++ because it could easy mislead the developer and make code hard to read.

Usage In Kotlin

To show the usage of operator overloading in Kotlin we will implement a simple Vector class with some overloading for the +(plus) and *(times) operator.

data class Vector(var x: Int, var y: Int) {
    operator fun plus(vector: Vector) = Vector(x + vector.x, y + vector.y)

    operator fun times(factor: Int) = Vector(x * factor, y * factor)

We define the Vector class analogous to the C++ class above with two fields as the corresponding coordinates.

With operator fun <operator> we can define the behavior for the given operator.

To call these operators we simply use the + and * character.

fun main(args: Array<String>) {
    val v = Vector(1, 1)

    println(v + Vector(3, 0))
    println(v * 8)

Use operator overloading judicious

We should learn from the bad reputation that operator overloading got in C++.

I would suggest to only use operator overloading when there is a proper mathematical representation for your behavior. Otherwise it can quickly turn into misleading and non maintainable code.

Always think twice if the operator you are implementing has really no better name than a single symbol.

Wrapping up

Kotlin operators allow us to write code that comes pretty close to mathematical representations. This can make code shorter and clearer. But they should be used with caution so they don’t end like the cout << "Hello World" example from C++.

The whole code it available on Github: kotlin_operator_overloading

Available operators

Valid operators are:

Left side describes the mathematical representation and the right word the corresponding operator verb.

Unary operations

Increments and Decrements

Binary operations

in operator

Invoke operator

Augmented assignments

Equality operators

All of these operators are described in depth in the official Kotlin documentation: Kotlin Documentation