Let function with safe calls in Kotlin - Step-by-Step Execution

Concept Flow - Let function with safe calls

Nullable variable

↓

Safe call operator ?

↓

If not null -> let block

↓

Execute code inside let

↓

Return let result or null

This flow shows how a nullable variable uses a safe call to run code inside let only if it is not null.

Execution Sample

Kotlin

val name: String? = "Anna"
name?.let {
  println("Hello, $it")
}

Prints greeting only if name is not null, using let with safe call.

Execution Table

Step	Variable 'name'	Safe call 'name?'	Let block executed?	Output
1	"Anna"	Not null	Yes	Hello, Anna
2	null	Null	No	(no output)

💡 Execution stops after let block runs or is skipped due to null.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
name	"Anna"	"Anna"	null	null

Key Moments - 2 Insights

Why does the let block not run when the variable is null?

Because the safe call operator '?' checks if the variable is null before calling let. If null, let is skipped (see execution_table row 2).

What does 'it' mean inside the let block?

'it' refers to the non-null value of the variable inside let, so you can use it safely (see execution_table row 1 output).

Visual Quiz - 3 Questions

Look at the execution table, what is printed when 'name' is "Anna"?

A "Hello, Anna"

B null

C No output

D Error

💡 Hint

Check execution_table row 1 under Output column.

At which step does the let block NOT execute?

A Step 1

B Step 2

C Both steps

D Never

💡 Hint

See execution_table row 2 under 'Let block executed?' column.

If 'name' was changed to null at start, what would be the output?

A "Hello, null"

B Error

C No output

D "Hello, Anna"

💡 Hint

Refer to variable_tracker and execution_table row 2 output.

Concept Snapshot

let function with safe calls:
- Use ?.let { } to run code only if variable is not null
- Inside let, 'it' is the non-null value
- If variable is null, let block is skipped
- Helps avoid null pointer errors
- Common for safe, concise null checks

Full Transcript

This visual trace shows how Kotlin's let function works with safe calls. A nullable variable 'name' is checked with ?.let. If 'name' is not null, the let block runs and prints a greeting using 'it' as the variable's value. If 'name' is null, the let block is skipped and nothing prints. The execution table shows two cases: when 'name' is "Anna" and when it is null. Variable tracker shows the value of 'name'. Key moments clarify why let runs only when not null and what 'it' means. The quiz tests understanding of output and let execution. This helps beginners see step-by-step how safe calls and let work together to handle nulls safely.

Practice

1. What does the Kotlin expression nullableVar?.let { println(it) } do?

easy

A. Prints the value of nullableVar only if it is not null.

B. Always prints null regardless of nullableVar.

C. Throws a NullPointerException if nullableVar is null.

D. Assigns nullableVar to it without printing.

Solution

1. Step 1: Understand safe call operator usage

   The ?. operator checks if nullableVar is not null before proceeding.

2. Step 2: Analyze the let function behavior

   If nullableVar is not null, let executes the lambda, printing the value.

3. Final Answer:

   Prints the value of nullableVar only if it is not null. -> Option A

4. Quick Check:

   ?.let runs code only if not null [OK]

Hint: Remember: ?.let runs code only when value is not null [OK]

Common Mistakes:

• Thinking it prints null when variable is null
• Assuming it throws an exception on null
• Confusing let with always running code

2. Which of the following is the correct syntax to safely print a nullable string name using let?

easy

A. name?.let { println(it) }

B. name.let { println(it) }

C. name?.let println(it)

D. name?.let { println(name) }

Solution

1. Step 1: Identify safe call usage

   To avoid null errors, ?.let must be used, not just .let.

2. Step 2: Check lambda syntax correctness

   The lambda must be enclosed in braces { } and use it to refer to the value.

3. Final Answer:

   name?.let { println(it) } -> Option A

4. Quick Check:

   Safe call + let with braces = correct syntax [OK]

Hint: Use ?.let { } with braces and 'it' inside [OK]

Common Mistakes:

• Omitting the safe call operator (?.)
• Missing braces around lambda
• Using variable name inside lambda instead of 'it'

3. What is the output of this Kotlin code?

val number: Int? = 5
number?.let { println(it * 2) }

medium

A. No output

B. 10

C. null

D. 5

Solution

1. Step 1: Check if number is null

   The variable number holds 5, which is not null, so ?.let runs.

2. Step 2: Calculate inside let block

   The lambda multiplies it (5) by 2 and prints 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Non-null value runs let, prints doubled value [OK]

Hint: If variable not null, let runs and prints result [OK]

Common Mistakes:

• Expecting no output if value is not null
• Confusing printed value with original variable
• Thinking it prints null when variable is non-null

4. Identify the error in this Kotlin code snippet:

val text: String? = null
text.let { println(it.length) }

medium

A. It prints 0 because null is treated as empty string.

B. It compiles but does not print anything.

C. It throws NullPointerException because safe call is missing.

D. It prints 'null' as a string.

Solution

1. Step 1: Check safe call usage

   The code uses text.let without ?., so it runs even if text is null.

2. Step 2: Understand null dereference

   Inside the lambda, it.length is called on null, causing a NullPointerException.

3. Final Answer:

   It throws NullPointerException because safe call is missing. -> Option C

4. Quick Check:

   Missing ?. causes null error [OK]

Hint: Always use ?.let to avoid null errors [OK]

Common Mistakes:

• Assuming let skips null without safe call
• Thinking null acts like empty string
• Ignoring possibility of NullPointerException

5. Given a nullable list of strings val names: List<String>? = listOf("Anna", "Bob", null, "Cara"), which Kotlin code safely prints only non-null names using let with safe calls?

hard

A. names?.let { it.forEach { println(it) } }

B. names.forEach { it.let { println(it) } }

C. names?.forEach { println(it) }

D. names?.forEach { it?.let { println(it) } }

Solution

1. Step 1: Handle nullable list safely

   Use names?.forEach to avoid errors if names is null.

2. Step 2: Filter out null elements inside the list

   Inside the loop, use it?.let to print only non-null names.

3. Final Answer:

   names?.forEach { it?.let { println(it) } } -> Option D

4. Quick Check:

   Safe calls on list and elements print only non-null [OK]

Hint: Use ?.forEach and it?.let to skip nulls safely [OK]

Common Mistakes:

• Not using safe call on list causing errors
• Printing null elements without filtering
• Using let without safe call on nullable elements