> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Pre-Increment
The `++` operator in Kotlin is a unary arithmetic operator used to increment the value of an assignable expression. Under the hood, it acts as syntactic sugar for the `inc()` operator function. Kotlin guarantees strict single-evaluation for the receiver, meaning the expression being incremented is evaluated exactly once, even if it involves custom getters or indexed access.
## Evaluation Strategies
The operator has two distinct syntactic forms that dictate the order of evaluation and the returned value. To prevent evaluating the receiver multiple times, the compiler utilizes temporary variables during resolution.
**1. Prefix (`++a`)**
The prefix form increments the expression and returns the newly incremented value.
* **Resolution:**
1. Evaluate the receiver `a` once and store its current value in a temporary variable (`temp = a`).
2. Call `inc()` on the temporary variable and assign the result back to `a` (`a = temp.inc()`).
3. Return the new value of `a`.
```kotlin theme={"dark"}
var a = 5
val b = ++a // a becomes 6, b is assigned 6
```
**2. Postfix (`a++`)**
The postfix form returns the original value of the expression before the increment occurs.
* **Resolution:**
1. Evaluate the receiver `a` once and store its current value in a temporary variable (`temp = a`).
2. Call `inc()` on the temporary variable and assign the result back to `a` (`a = temp.inc()`).
3. Return the original cached value (`temp`).
```kotlin theme={"dark"}
var x = 5
val y = x++ // y is assigned 5, x becomes 6
```
## Operator Overloading
To utilize the `++` operator with custom types, the class must define an `inc()` method prefixed with the `operator` modifier. Because the `++` operator inherently performs a reassignment, the `inc()` function must return a new instance (or the mutated instance) that is assignable back to the original expression.
```kotlin theme={"dark"}
class Counter(val value: Int) {
operator fun inc(): Counter {
return Counter(value + 1)
}
}
var myCounter = Counter(10)
myCounter++ // Resolves using the single-evaluation strategy: temp = myCounter; myCounter = temp.inc()
```
## Compiler Requirements
* **Assignable Expression:** The operand must be an assignable expression. While this includes mutable variables (`var`), it also encompasses mutable properties and indexed access expressions (e.g., `array[0]++` or `list[i]++`), even if the array or list reference itself is declared as a read-only `val`.
* **Type Compatibility:** The return type of the `inc()` function must be the same type as the original expression, or a subtype, to satisfy the implicit `a = temp.inc()` reassignment step.
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
