Operator overloading

Further we describe the conventions that regulate operator overloading for different operators.

This table says that when the compiler processes, for example, an expression +a, it performs the following steps:

• Determines the type of a, let it be T;
• Looks up a function unaryPlus() with the operator modifier and no parameters for the receiver T, i.e. a member function or an extension function;
• If the function is absent or ambiguous, it is a compilation error;
• If the function is present and its return type is R, the expression +a has type R;

Note that these operations, as well as all the others, are optimized for Basic types and do not introduce overhead of function calls for them.

As an example, here’s how you can overload the unary minus operator:

Increments and decrements

The inc() and dec() functions must return a value, which will be assigned to the variable on which the ++ or -- operation was used. They shouldn’t mutate the object on which the inc or dec was invoked.

The compiler performs the following steps for resolution of an operator in the postfix form, e.g. a++:

• Determines the type of a, let it be T;
• Looks up a function inc() with the operator modifier and no parameters, applicable to the receiver of type T;
• Checks that the return type of the function is a subtype of T.

The effect of computing the expression is:

• Store the initial value of a to a temporary storage a0;
• Assign the result of a0.inc() to a;

For the prefix forms ++a and --a resolution works the same way, and the effect is:

• Assign the result of a.inc() to a;
• Return the new value of a as a result of the expression.

Arithmetic operators

For the operations in this table, the compiler just resolves the expression in the Translated to column.

Note that the rem operator is supported since Kotlin 1.1. Kotlin 1.0 uses the mod operator, which is deprecated in Kotlin 1.1.

Example

Below is an example Counter class that starts at a given value and can be incremented using the overloaded + operator:

data class Counter(val dayIndex: Int) {
    operator fun plus(increment: Int): Counter {
        return Counter(dayIndex + increment)
    }
}

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

Indexed access operator

Square brackets are translated to calls to get and set with appropriate numbers of arguments.

Invoke operator

Parentheses are translated to calls to invoke with appropriate number of arguments.

• If the function from the right column is available
  • If the corresponding binary function (i.e. plus() for plusAssign()) is available too, report error (ambiguity),
  • Make sure its return type is Unit, and report an error otherwise,
  • Generate code for a.plusAssign(b);

Note: assignments are NOT expressions in Kotlin.

Equality and inequality operators

These operators only work with the function , which can be overridden to provide custom equality check implementation. Any other function with the same name (like equals(other: Foo)) will not be called.

Note: === and !== (identity checks) are not overloadable, so no conventions exist for them.

The == operation is special: it is translated to a complex expression that screens for null‘s. null == null is always true, and x == null for a non-null x is always false and won’t invoke x.equals().

Comparison operators

All comparisons are translated into calls to compareTo, that is required to return Int.

provideDelegate, getValue and operator functions are described in .

We can simulate custom infix operations by using infix function calls.