Idioms and Stdlib

// One line replaces ~50 lines of Java
data class User(val name: String, val age: Int, val email: String)

fun main() {
    val alice = User("Alice", 30, "alice@example.com")
    val bob   = User("Bob",   25, "bob@example.com")

    // toString() auto-generated
    println(alice)   // User(name=Alice, age=30, email=alice@example.com)

    // equals() compares by content, not reference
    val alice2 = User("Alice", 30, "alice@example.com")
    println(alice == alice2)   // true (structural equality)

    // copy(): create a modified version without mutation
    val olderAlice = alice.copy(age = 31)
    println(olderAlice)   // User(name=Alice, age=31, email=alice@example.com)
    println(alice)        // unchanged

    // Destructuring declarations — component functions auto-generated
    val (name, age, email) = alice
    println("$name is $age years old")

    // Works in for loops
    val users = listOf(alice, bob)
    for ((n, a) in users) {
        println("$n: $a")
    }
}

// Extend String with a new method
fun String.isValidEmail(): Boolean {
    return contains("@") && contains(".")
}

// Extend Int with a range check
fun Int.isInRange(min: Int, max: Int) = this in min..max

// Extension on nullable type
fun String?.orEmpty(): String = this ?: ""

fun main() {
    println("alice@example.com".isValidEmail())   // true
    println("not-an-email".isValidEmail())        // false
    println(42.isInRange(1, 100))                 // true

    val s: String? = null
    println(s.orEmpty())   // "" (extension on nullable)

    // Stdlib extensions you use constantly:
    val nums = listOf(1, 2, 3, 4, 5)
    println(nums.filter { it > 2 })          // [3, 4, 5]
    println(nums.map { it * it })            // [1, 4, 9, 16, 25]
    println(nums.sumOf { it })               // 15
    println(nums.groupBy { it % 2 == 0 })   // {false=[1,3,5], true=[2,4]}
}

data class Config(var host: String = "", var port: Int = 0, var debug: Boolean = false)

fun main() {
    // apply: configure an object — returns the object; "this" inside
    val config = Config().apply {
        host = "localhost"   // this.host = ...
        port = 8080
        debug = true
    }
    println(config)   // Config(host=localhost, port=8080, debug=true)

    // let: transform a value — returns lambda result; "it" inside
    // Most useful for null-safe operations
    val name: String? = "Alice"
    val greeting = name?.let { "Hello, $it!" } ?: "Hello!"
    println(greeting)   // Hello, Alice!

    // also: side effect — returns the object; "it" inside
    val nums = mutableListOf(1, 2, 3)
        .also { println("Before: $it") }
        .apply { add(4) }
        .also { println("After: $it") }

    // run: compute a result — returns lambda result; "this" inside
    val length = "Hello Kotlin".run {
        println("String: $this")
        length   // lambda result
    }
    println(length)   // 12

    // with: non-extension version of run — pass object as argument
    val result = with(config) {
        "$host:$port (debug=$debug)"
    }
    println(result)   // localhost:8080 (debug=true)
}