Kotlin : 100 Interview Questions and Answers PART18

86. The concept of lazy evaluation in Kotlin

Lazy evaluation is a programming concept where a value is not computed until it is actually needed.

In Kotlin, this is implemented using the lazy delegate — a powerful and simple way to defer initialization of a property until it's first accessed.

Syntax: lazy

val myValue: String by lazy {
    println("Computed!")
    "Hello from Lazy"
}

• - The lambda inside lazy { ... } runs only once — the first time myValue is accessed.
• - After that, the cached value is returned.

Output Example

fun main() {
    println("Before access")
    println(myValue)   // Triggers computation
    println(myValue)   // Uses cached value
}

Output:
Before access
Computed!
Hello from Lazy
Hello from Lazy

How It Works

• - The lazy function returns an implementation of the Lazy<T> interface.
• - By default, it's thread-safe (LazyThreadSafetyMode.SYNCHRONIZED), but can be customized.

Common Use Cases

87. What is a closure in Kotlin?

A closure in Kotlin is a function that captures variables from its surrounding scope — even after that scope has exited. This allows the function to remember and access those variables later.

Closure = Lambda/function + captured environment

Example of a Closure in Kotlin

fun counter(): () -> Int {
    var count = 0
    return {
        count += 1
        count
    }
}

val increment = counter()
println(increment()) // 1
println(increment()) // 2
println(increment()) // 3

What's Happening Here?

• - counter() returns a lambda.
• - That lambda remembers the variable count, even though the counter() function has finished executing.
• - count is captured by the returned function — this is the closure.

Why Closures Are Useful

• - You can maintain state between function calls
• - Useful for callbacks, event handlers, and functional programming
• - Used heavily in Kotlin DSLs, Jetpack Compose, and coroutines

Another Example: Closure with Filtering

fun makeFilter(limit: Int): (Int) -> Boolean {
    return { it > limit }
}

val filter = makeFilter(10)
println(filter(5))  // false
println(filter(15)) // true

The lambda closes over limit.

88. Closure vs Lambda

• Lambda: A small function, usually stateless
• Closure: A lambda with memory — it captures values from surrounding scope

Here's a clear comparison table showing the difference between Closures and Lambdas, particularly in Kotlin (and also applicable in general programming):

89. The concept of the until keyword in Kotlin

In Kotlin, until is a range function used to create a range of values that is exclusive of the upper bound.

Syntax

start until end

This creates a range from start up to but not including end.

Equivalent to: start..(end - 1)

Example

for (i in 1 until 5) {
    println(i)
}

Output:

1
2
3
4

As you can see, 5 is not included.

When to Use until

- Avoiding off-by-one errors when working with ranges.

- Looping over indices of a list or array (excluding lastIndex + 1):

val list = listOf("a", "b", "c")
for (i in 0 until list.size) {
    println(list[i])
}

90. until vs .. in table with example

Here's a clear comparison between Kotlin's .. and until operators using a table, along with examples:

Examples:

Using ..

for (i in 1..5) {
    print("$i ")
}
Output: 1 2 3 4 5

Includes 5

Using until

for (i in 1 until 5) {
    print("$i ")
}

Output: 1 2 3 4

Excludes 5

Important :