Operator overloading

Kotlin allows us to provide implementations for a predefined set of operators on our types. These operators have fixed symbolic representation (like + or *) and fixed precedence. To implement an operator, we provide a member function or an extension function with a fixed name, for the corresponding type, i.e. left-hand side type for binary operations and argument type for unary ones. Functions that overload operators need to be marked with the operator modifier.

Conventions

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

Unary operations

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.

These operations are supposed to change their receiver and (optionally) return a value.

inc()/dec() shouldn't mutate the receiver object.
By "changing the receiver" we mean the receiver-variable, not the receiver object. {:.note}

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.
• If the function returns a type R, then it must be 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 a.inc() to a,
• Return a0 as a result of the expression.

For a-- the steps are completely analogous.

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.

Binary operations

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

For in and !in the procedure is the same, but the order of arguments is reversed. {:#in}

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

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

{:#assignments}

For the assignment operations, e.g. a += b, the compiler performs the following steps:

• 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)
• Otherwise, try to generate code for a = a + b (this includes a type check: the type of a + b must be a subtype of a).

Note: assignments are NOT expressions in Kotlin. {:#Equals}

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, and null == null is true.

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

Infix calls for named functions

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