Kotlin Gotchas

data class Point(val x: Int, val y: Int)

val a = Point(1, 2)
val b = Point(1, 2)

println(a == b)   // true: equals() compares x and y
println(a === b)  // false: two distinct instances

// Boxed integers outside the cached range (-128..127) show the
// same trap Java has, if you ever do reach for ===
val n1: Int? = 200
val n2: Int? = 200
println(n1 == n2)   // true: structural
println(n1 === n2)  // false: different boxed Integer objects outside the cache

data class Task(val id: Int, var completed: Boolean)

val task = Task(1, completed = false)
val tasks = hashSetOf(task)

println(task in tasks)  // true

task.completed = true       // mutates the var — hashCode() changes as a side effect

println(task in tasks)  // false! the set is still bucketed by the OLD hash
println(tasks.size)     // 1: the object is still physically in there, just unreachable by equals

class ShoppingCart {
    private val _items = mutableListOf<String>()

    // Looks safe: callers get a List, not a MutableList
    val items: List<String> get() = _items

    fun add(item: String) = _items.add(item)
}

val cart = ShoppingCart()
val snapshot = cart.items   // looks like a safe read-only reference...
cart.add("apples")

println(snapshot)  // [apples] — "snapshot" was never actually a snapshot;
                     // it's the same list, seen through a narrower type

// apply returns the RECEIVER, not the lambda's last expression —
// easy to reach for when you actually wanted let's return value
val length = "hello".apply {
    uppercase()   // this result is discarded!
}
println(length)  // "hello": apply always returns the original receiver

// let returns the lambda's last expression — this is what was meant
val upper = "hello".let {
    it.uppercase()
}
println(upper)  // "HELLO"

val users = listOf("Ada", "Grace")
val lengths = listOf(3, 5)

// Both lambdas use `it` implicitly — the inner one silently
// shadows the outer, and this compiles without a warning
users.forEach {
    lengths.filter { it > 3 }.forEach {
        println(it)  // which "it"? the innermost one — easy to misread at a glance
    }
}

// Fix: name at least the outer parameter explicitly
users.forEach { user ->
    lengths.filter { it > 3 }.forEach { len ->
        println("$user: $len")
    }
}

class ReportView {
    lateinit var title: String

    fun render(): String = "Report: $title"
}

val view = ReportView()
// Forgot to call view.title = "..." before this — compiles fine,
// crashes only when render() is actually called
println(view.render())
// kotlin.UninitializedPropertyAccessException:
//   lateinit property title has not been initialized

// Guard against it explicitly when the assignment isn't guaranteed
// by a framework lifecycle you control
if (view::title.isInitialized) {
    println(view.render())
}

// No bound written means T : Any? implicitly — T can be nullable
class Box<T>(val value: T)

val box: Box<String?> = Box(null)  // compiles fine: T inferred as String?
println(box.value?.length)             // must still null-check to use it

// Constrain T : Any to rule nullable types out entirely
class NonNullBox<T : Any>(val value: T)
// val bad: NonNullBox = NonNullBox(null)  // ERROR: T bound to Any excludes String?
val good = NonNullBox("Ada")  // fine: T inferred as String (non-null)

fun findFirstNegative(numbers: List<Int>): Int? {
    numbers.forEach {
        if (it < 0) {
            return it   // returns from findFirstNegative — this one actually works as intended
        }
    }
    return null
}

fun printAllPositive(numbers: List<Int>) {
    numbers.forEach {
        if (it < 0) {
            return       // BUG: exits printAllPositive entirely on the FIRST negative,
        }                     // not just skipping this one element like "continue" would
        println(it)
    }
    println("done")   // never reached if any number was negative
}

// Fix: a labeled return targets only the current lambda invocation
fun printAllPositiveFixed(numbers: List<Int>) {
    numbers.forEach {
        if (it < 0) return@forEach   // skips just this element
        println(it)
    }
    println("done")   // now always reached
}

var logCount = 0
fun logAndReturnDefault(): String {
    logCount++
    return "default"
}

val name: String? = "Ada"

// Easy to assume the log call always runs "as part of the expression" —
// it doesn't, because ?: only evaluates its right side when needed
val result = name ?: logAndReturnDefault()
println(logCount)  // 0: name wasn't null, so logAndReturnDefault() never ran

val missing: String? = null
val result2 = missing ?: logAndReturnDefault()
println(logCount)  // 1: this time it did run

val max = Int.MAX_VALUE
println(max)          // 2147483647
println(max + 1)      // -2147483648: silently wrapped, no exception

// A realistic trigger: summing a large list of Ints
val largeNumbers = List(3) { Int.MAX_VALUE }
println(largeNumbers.sum())  // wraps to a negative, nonsensical total

// Fixes: use Long for values that can plausibly grow large,
// or use the checked arithmetic functions that throw instead of wrapping
val total: Long = largeNumbers.sumOf { it.toLong() }
println(total)  // 6442450941: correct

val checked = Math.addExact(max, 1)  // throws ArithmeticException on overflow

class UserRepository {
    fun refreshInBackground() {
        // No CoroutineScope available in this non-suspend function,
        // so it's tempting to reach for GlobalScope to make it compile
        GlobalScope.launch {
            delay(5000)
            syncWithServer()
        }
        // This coroutine has no parent. Nothing cancels it if the
        // repository, the screen, or the whole feature is torn down
        // first — it keeps running, potentially touching freed state.
    }
}

// Fix: give the class its own scope tied to a real lifecycle,
// and cancel it explicitly when that lifecycle ends
class UserRepositoryFixed(
    private val scope: CoroutineScope
) {
    fun refreshInBackground() {
        scope.launch {
            delay(5000)
            syncWithServer()
        }
    }
}
// scope.cancel() when the repository's owner is done with it —
// now the launched work is provably bounded by a real lifetime