Let function with safe calls in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of let with safe call on nullable String

What is the output of this Kotlin code snippet?

Kotlin

val name: String? = "Anna"
val result = name?.let { it.uppercase() } ?: "No name"
println(result)

A ANNA

B No name

C anna

D null

💡 Hint

Remember that let runs only if the value is not null and uppercase converts to capital letters.

The safe call ?. lets the let block run only if name is not null. Since name is "Anna", let converts it to uppercase, so output is "ANNA".

❓ Predict Output

intermediate

Result of let with null value and safe call

What will be printed by this Kotlin code?

Kotlin

val number: Int? = null
val output = number?.let { it * 2 } ?: -1
println(output)

A Exception

B -1

C null

D 0

💡 Hint

If the variable is null, let block does not run and the Elvis operator ?: provides the default.

Since number is null, the safe call ?. skips let and the Elvis operator returns -1, so output is -1.

🔧 Debug

advanced

Identify the error in let with safe call

This Kotlin code is intended to print the length of a nullable string if it is not null. What error will it produce?

Kotlin

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

A Prints 0

B NullPointerException

C Compilation error: Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver

D Prints null

💡 Hint

Check how let is called on a nullable variable without safe call operator.

Calling let directly on a nullable variable without safe call causes a compilation error because the receiver might be null.

❓ Predict Output

advanced

Output of nested let with safe calls

What is the output of this Kotlin code?

Kotlin

val a: String? = "Hi"
val b: String? = null
val result = a?.let { x -> b?.let { y -> x + y } } ?: "Empty"
println(result)

A Empty

B Hi

C Hinull

D null

💡 Hint

The inner let runs only if b is not null. If b is null, the whole expression after ?: is used.

Since b is null, b?.let does not run and the outer let returns null, so Elvis operator returns "Empty".

❓ Predict Output

expert

Value of variable after let with safe call and side effect

Consider this Kotlin code. What is the final value of the variable 'counter' after execution?

Kotlin

var counter = 0
var text: String? = "abc"
text?.let {
    counter += it.length
}
text = null
text?.let {
    counter += it.length
}
println(counter)

A Compilation error

B 0

C 6

D 3

💡 Hint

The let block runs only when the variable is not null. The second let does not run because text is null.

The first let runs and adds 3 to counter. The second let does not run because text is null. So counter is 3.

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