Operator Overloading

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

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    println(p1 + p2)
}

class Money(val cents: Int) {
    override fun equals(other: Any?): Boolean {
        return other is Money && other.cents == cents
    }
    override fun hashCode(): Int = cents
}

fun main() {
    val a = Money(500)
    val b = Money(500)
    println("Equal: ${a == b}")
}

class Grid(val values: List<List<Int>>) {
    operator fun get(row: Int, col: Int): Int = values[row][col]
}

fun main() {
    val grid = Grid(listOf(listOf(1, 2), listOf(3, 4)))
    println("Value at (1, 0): ${grid[1, 0]}")
}

class Greeter(val greeting: String) {
    operator fun invoke(name: String): String = "$greeting, $name!"
}

fun main() {
    val greeter = Greeter("Hello")
    println(greeter("Kotlin"))
}

1. Forgetting the operator keyword before a function named to match an operator convention, such as plus, which is required for the overload to actually work.
2. Overloading an operator in a way that surprises users, such as making + perform subtraction, which harms readability rather than helping it.
3. Not matching the exact expected function signature (name and parameter count) for the operator being overloaded.

• Operators like +, -, *, and == map to specific function names (plus, minus, times, equals) that can be overloaded with the operator keyword.
• Overloaded operator functions must be marked operator fun and follow the exact expected signature for that operator.
• Overloading [] access uses get/set, and calling an object like a function uses invoke.
• Operator overloads should behave in a way that matches the operator's normal, expected meaning to keep code readable.