Scope-Limited Processing with let

// ?.let skips execution when the value is null.
val name: String? = "Alice"
name?.let {
    println(it.length)  // Runs only if name is non-null.
}

// Capture the result (null if the value was null).
val result: Int? = name?.let { it.length * 2 }

// Comparison with an if null check
if (name != null) {
    println(name.length)  // Smart cast
}
// Equivalent using ?.let:
name?.let { println(it.length) }

data class User(val name: String, val email: String?)

fun findUser(id: Int): User? = if (id == 1) User("Alice", "alice@example.com") else null

fun main() {
    // Basic ?.let usage
    val name: String? = "Kotlin"
    name?.let {
        println("Length: ${it.length}")  // Length: 6
        println("Uppercase: ${it.uppercase()}")  // Uppercase: KOTLIN
    }

    // Skipped when the value is null.
    val nullName: String? = null
    nullName?.let { println("This will not run.") }
    println("Skipped null.")  // Skipped null.

    // Capture the result.
    val length: Int? = name?.let { it.length * 2 }
    println("Double the length: $length")  // Double the length: 12

    // Combine with ?: (Elvis operator).
    val nullLength: Int = nullName?.let { it.length } ?: -1
    println("Default when null: $nullLength")  // -1

    // Chain nested nullables.
    val user: User? = findUser(1)
    user?.let { u ->
        u.email?.let { email ->
            println("Email: $email")  // Email: alice@example.com
        }
    }

    // findUser(99) returns null, so this is skipped.
    findUser(99)?.let { println("User: ${it.name}") }
    println("Skipped non-existent user.")

    // Process nullable elements in a list.
    val names: List<String?> = listOf("Alice", null, "Bob", null, "Carol")
    names.forEach { it?.let { name -> println(name) } }
}

?.let is one of the most commonly used null-check patterns in Kotlin. It is equivalent to if (value != null) { ... }, but because it is a scope function, you can assign its result to a variable or chain it with other calls.

The parameter inside the lambda defaults to it, but giving it an explicit name — such as ?.let { user -> ... } — improves readability when lambdas are nested.

For the basics of nullable types, see Nullable types / ?. operator. For scope functions in general, see let.