Lazy property delegation in Kotlin - Step-by-Step Execution

Concept Flow - Lazy property delegation

Declare lazy property

↓

Access property first time?

No→Return cached value

Yes↓

Run initializer lambda

↓

Store result

↓

Return stored value

When you declare a lazy property, its value is not created until you use it the first time. Then it saves the value and returns it on later uses.

Execution Sample

Kotlin

val lazyValue by lazy {
    println("Computing value...")
    "Hello"
}

println(lazyValue)
println(lazyValue)

This code creates a lazy property that prints a message and returns "Hello" only when accessed the first time, then reuses the value.

Execution Table

Step	Action	Lazy Property State	Output
1	Declare lazyValue with initializer	Not initialized
2	Access lazyValue first time	Not initialized
3	Run initializer lambda	Initializing	Computing value...
4	Store result "Hello"	Initialized with "Hello"
5	Return stored value	Initialized with "Hello"	Hello
6	Access lazyValue second time	Initialized with "Hello"
7	Return stored value without running initializer	Initialized with "Hello"	Hello

💡 After first access, lazyValue is initialized and reused without running initializer again.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 7
lazyValue	Not initialized	Initializing	Initialized with "Hello"	Initialized with "Hello"

Key Moments - 2 Insights

Why does "Computing value..." print only once even though we access lazyValue twice?

Because at step 3 the initializer runs only once and stores the result at step 4. Later accesses (step 7) reuse the stored value without running the initializer again.

What happens if we never access lazyValue?

The initializer lambda never runs, so "Computing value..." is never printed and the value is never created, as shown by the state staying "Not initialized" in step 1.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of lazyValue after step 4?

A Initialized with "Hello"

B Initializing

C Not initialized

D Uninitialized but accessed

💡 Hint

Check the 'Lazy Property State' column at step 4 in the execution_table.

At which step does the initializer lambda run?

A Step 2

B Step 3

C Step 5

D Step 7

💡 Hint

Look for the step where 'Run initializer lambda' happens in the Action column.

If we never accessed lazyValue, what would be printed?

A "Computing value..." once

B "Hello" once

C Nothing

D "Computing value..." twice

💡 Hint

Refer to the key_moments about what happens if lazyValue is never accessed.

Concept Snapshot

Lazy property delegation in Kotlin:
- Declare with 'val x by lazy { initializer }'
- Initializer runs only on first access
- Result is stored and reused
- Saves resources by delaying computation
- Useful for expensive or optional values

Full Transcript

Lazy property delegation means the value is created only when you first use it. The code declares a lazy property with an initializer lambda. When you access the property the first time, the lambda runs, prints a message, and returns a value. This value is saved. On later accesses, the saved value is returned directly without running the lambda again. If you never access the property, the initializer never runs. This helps save work until needed.

Practice

1. What does lazy property delegation in Kotlin do?

easy

A. Deletes the property value after each use

B. Delays the creation of a property value until it is first accessed

C. Creates the property value immediately when the object is created

D. Allows multiple values to be stored in the same property

Solution

1. Step 1: Understand lazy delegation concept

   Lazy delegation means the property value is not created when the object is made, but only when the property is accessed for the first time.

2. Step 2: Compare options with this concept

   Delays the creation of a property value until it is first accessed matches this behavior exactly. Options A, B, and D describe different behaviors not related to lazy delegation.

3. Final Answer:

   Delays the creation of a property value until it is first accessed -> Option B

4. Quick Check:

   Lazy property = delayed creation [OK]

Hint: Lazy means create value only when first needed [OK]

Common Mistakes:

• Thinking lazy creates value immediately
• Confusing lazy with caching multiple values
• Assuming lazy deletes values after use

2. Which of the following is the correct syntax to declare a lazy property in Kotlin?

easy

A. val name = lazy("John")

B. val name = lazy { "John" }

C. val name by lazy { "John" }

D. lazy val name = "John"

Solution

1. Step 1: Recall Kotlin lazy syntax

   In Kotlin, lazy properties use the syntax: val propertyName by lazy { initializer }.

2. Step 2: Match options with correct syntax

   val name by lazy { "John" } matches this exactly. val name = lazy { "John" } assigns lazy delegate but does not use 'by'. lazy val name = "John" uses invalid order. val name = lazy("John") uses wrong function call syntax.

3. Final Answer:

   val name by lazy { "John" } -> Option C

4. Quick Check:

   Use 'by lazy { }' for lazy property [OK]

Hint: Remember: val x by lazy { ... } [OK]

Common Mistakes:

• Omitting 'by' keyword
• Using lazy() as a function call incorrectly
• Placing 'lazy' before 'val'

3. What will be the output of this Kotlin code?

val lazyValue by lazy {
    println("Computing...")
    10
}

fun main() {
    println(lazyValue)
    println(lazyValue)
}

medium

A. Computing...\n10\n10

B. 10\n10

C. Computing...\n10\nComputing...\n10

D. Computing...\nComputing...\n10\n10

Solution

1. Step 1: Understand lazy initialization behavior

   The lambda inside lazy runs only once, when the property is first accessed. It prints "Computing..." and returns 10.

2. Step 2: Trace the program output

   First println(lazyValue) triggers lazy initialization, printing "Computing..." then 10. Second println(lazyValue) uses cached value, printing only 10.

3. Final Answer:

   Computing...\n10\n10 -> Option A

4. Quick Check:

   Lazy runs once, then caches value [OK]

Hint: Lazy block runs once, then cached value used [OK]

Common Mistakes:

• Assuming lazy block runs every access
• Missing that println inside lazy prints once
• Confusing output order

4. Identify the error in this Kotlin code using lazy delegation:

class Example {
    val number = lazy { 5 }
}

fun main() {
    val e = Example()
    println(e.number)
}

medium

A. The lazy block must return a String, not Int

B. The println statement is missing parentheses

C. The lazy delegate cannot be used inside a class

D. The property 'number' should be declared with 'by lazy', not assigned directly

Solution

1. Step 1: Check lazy property declaration

   The property 'number' is assigned lazy { 5 } directly, but lazy delegation requires 'by lazy' syntax.

2. Step 2: Identify correct syntax

   Correct declaration is 'val number by lazy { 5 }'. Without 'by', 'number' is a Lazy<Int> object, not the Int value.

3. Final Answer:

   The property 'number' should be declared with 'by lazy', not assigned directly -> Option D

4. Quick Check:

   Use 'by lazy' keyword for lazy properties [OK]

Hint: Lazy needs 'by lazy', not just assignment [OK]

Common Mistakes:

• Omitting 'by' keyword
• Confusing lazy delegate type with property type
• Thinking lazy only works outside classes

5. You want to create a Kotlin class where a heavy computation is done only once and reused, but the computation depends on a constructor parameter. How should you use lazy delegation to achieve this?

class Calculator(val input: Int) {
    val result by lazy { /* ??? */ }
}

Which is the correct way to implement the lazy block?

hard

A. val result by lazy { compute() } // where compute() is a member function

B. val result by lazy { Calculator(input).compute() }

C. val result by lazy { input }

D. val result by lazy { input * 2 }

Solution

1. Step 1: Understand lazy with constructor parameter

   The lazy block can access constructor parameters and member functions. Using a member function keeps code clean and reusable.

2. Step 2: Evaluate options

   val result by lazy { input * 2 } uses input directly, which works but may duplicate logic. val result by lazy { Calculator(input).compute() } creates a new Calculator inside lazy, causing recursion. val result by lazy { input } just returns input, no computation. val result by lazy { compute() } // where compute() is a member function calls a member function compute(), which can use input and perform heavy work once.

3. Final Answer:

   val result by lazy { compute() } // where compute() is a member function -> Option A

4. Quick Check:

   Use member function inside lazy for complex computation [OK]

Hint: Call member function inside lazy for complex work [OK]

Common Mistakes:

• Creating new instance inside lazy causing recursion
• Using constructor parameter directly without logic
• Returning parameter without computation