Generics,
Lambdas &
Functions

// ✗ WITHOUT generics — unsafe, verbose, error-prone
fun getFirst(list: List<Any>): Any = list[0]
val s = getFirst(listOf("a")) as String // runtime cast, can throw

// ✓ WITH generics — type-safe, no cast needed
fun <T> getFirst(list: List<T>): T = list[0]
val s: String = getFirst(listOf("a")) // compiler checks T = String

// TYPE ERASURE: at runtime both are the same bytecode
// List<String> == List<Int> == List (raw type) to the JVM
val ls: List<String> = listOf("a")
val li: List<Int>    = listOf(1)
println(ls.javaClass == li.javaClass) // true! Both are ArrayList

// CONSEQUENCE: can't check generic types at runtime
if (ls is List<String>) { }  // ✗ Compile error: erased type
if (ls is List<*>) { }      // ✓ Star projection allowed

// List<*> = List<out Any?>: can READ Any?, cannot WRITE
fun printAll(list: List<*>) {
    list.forEach { println(it) }   // ✓ read as Any?
    list.add("x")                  // ✗ can't add — type unknown
}

// MutableList<*> = MutableList<out Any?> for reads
// Cannot call methods that take T as parameter
val ml: MutableList<*> = mutableListOf("a", "b")
val item = ml[0]   // type is Any? — need cast to use
ml.add("c")        // ✗ Error: Nothing is passed as T

// Map<*, String>: key type unknown, value is String
// Map<String, *>: key is String, value type unknown
fun valuesOf(map: Map<*, String>): List<String> =
    map.values.toList()

// Nothing as lower bound: for out-projected write-only
// Foo<in *> ≡ Foo<in Nothing>: can't pass any value

// Source code
inline fun measure(block: () -> Unit) {
    val t = System.nanoTime()
    block()
    println(System.nanoTime() - t)
}
measure { doWork() }

// What the compiler generates at call site:
// (no measure() call, no Function object)
val t = System.nanoTime()
doWork()                       // ← block body pasted
println(System.nanoTime() - t)

// Without inline — generated bytecode:
// val fn = new Function0() { void invoke() { doWork(); } }
// measure(fn)
// → INVOKEVIRTUAL Function0.invoke  (virtual dispatch)
// → heap allocation for fn object

// Function types and their FunctionN equivalents
val f0: () -> Unit              // Function0<Unit>
val f1: (Int) -> String        // Function1<Int, String>
val f2: (Int, String) -> Bool  // Function2<Int, String, Bool>

// Kotlin suspending lambda type
val sf: suspend () -> Unit      // SuspendFunction0<Unit>

// Lambda with receiver type
val ext: String.() -> Int       // Function1<String, Int> (receiver = first param)

// ── Allocation analysis ────────────────────────────────────
// NON-CAPTURING: compiled to a SINGLETON object
val pure = { x: Int -> x * 2 }      // one object ever
list.map { it * 2 }                  // reuses same singleton

// CAPTURING: NEW object per call context
fun multiplier(n: Int) = { x: Int -> x * n }
val times3 = multiplier(3)  // allocates object with n=3
val times5 = multiplier(5)  // allocates another with n=5

// MUTABLE CAPTURE: captured variable wrapped in a Ref object
var count = 0
val inc = { count++ }          // count wrapped in IntRef()
// Bytecode: val ref = new IntRef(); ref.element = 0
// { ref.element++ }

// IMMUTABLE CAPTURE — val captured directly in lambda
val prefix = "Hello"
val greet: (String) -> String = { "$prefix, $it" }
// 'prefix' is a String (immutable), copied into lambda object field

// MUTABLE CAPTURE — var wrapped in Ref by compiler
var total = 0
val items = listOf(1, 2, 3)
items.forEach { total += it }  // captures and mutates total
println(total)  // 6
// Compiled as: val totalRef = IntRef(); totalRef.element = 0
// lambda: { totalRef.element += it }

// COMMON PITFALL: capture in loop
val fns = mutableListOf<() -> Int>()
for (i in 0..2) {
    fns.add { i }  // each lambda captures the IntRef of i
}
// All fns reference the SAME IntRef. After loop, i=3.
fns.map { it() }  // [0, 1, 2] — actually OK, range is immutable
// But with var i = 0; while(i < 3): fns would all return 3!

// SOLUTION for the pitfall: capture a snapshot
for (i in 0..2) {
    val snapshot = i  // new immutable capture each iteration
    fns.add { snapshot }
}

// ── Java SAM: Runnable ────────────────────────────────────
// Java: executor.execute(new Runnable() { public void run() { } })
executor.execute { println("hello") }   // SAM conversion
executor.execute(Runnable { println("hello") }) // explicit

// Comparator<in T> — Java SAM with generic
val comparator: Comparator<String> = Comparator { a, b ->
    a.length - b.length
}
// Or concisely:
listOf("banana", "fig", "apple").sortedWith { a, b ->
    a.length - b.length
}

// ── Kotlin fun interface ──────────────────────────────────
fun interface Transformer<T, R> {
    fun transform(input: T): R           // single abstract method
    fun andThen(other: Transformer<R, R>)  // non-abstract: allowed
        : Transformer<T, R> = Transformer { other.transform(transform(it)) }
}
val double: Transformer<Int, Int> = { it * 2 }  // SAM conversion
println(double.transform(5))  // 10

// Extension function: calls obj.doSomething()
fun StringBuilder.addHello() = append("hello")

// Lambda with receiver: same access, but as a value
val addHello: StringBuilder.() -> Unit = { append("hello") }
// These are semantically equivalent. The lambda is a function
// value with StringBuilder as its implicit 'this'.

// Calling a receiver lambda:
val sb = StringBuilder()
sb.addHello()       // extension function call
sb.addHello()       // receiver lambda called on sb
// OR: addHello(sb) — receiver is first parameter under the hood

// The stdlib 'apply' is just this pattern:
inline fun <T> T.apply(block: T.() -> Unit): T {
    block()    // 'this' inside block = the T receiver
    return this
}
// Usage: creates new AlertDialog with configuration
AlertDialog.Builder(ctx).apply {
    setTitle("Warning")   // this = Builder, no 'this.' needed
    setMessage("Sure?")
}.create()

@DslMarker
@Target(AnnotationTarget.CLASS)
annotation class HtmlDsl

@HtmlDsl class Table {
    fun tr(init: Tr.() -> Unit) { Tr().apply(init) }
}
@HtmlDsl class Tr {
    fun td(text: String) { println("<td>$text</td>") }
}
fun table(init: Table.() -> Unit) = Table().apply(init)

table {
    tr {
        td("cell")          // ✓ Tr.td() — correct
        tr { }               // ✗ Error: can't access Table.tr() from Tr scope
        // Without @DslMarker, this would compile and be confusing
    }
}

// Without @DslMarker — the problem:
table {
    tr {
        tr { }    // Would call Table.tr() from inside Tr — confusing!
    }
}