Let function with safe calls in Kotlin

Introduction

The let function helps you run code only when a value is not null. It keeps your program safe from errors caused by missing values.

When you want to do something only if a variable is not null.

When you want to avoid writing extra checks for null values.

When you want to work with a value inside a small block of code safely.

When you want to chain calls on a variable that might be null.

When you want to keep your code clean and easy to read.

Syntax

Kotlin

variable?.let { nonNullValue ->
    // code using nonNullValue
}

The ?. is a safe call operator that runs let only if variable is not null.

Inside let, the value is not null and can be used safely as nonNullValue.

Examples

This prints a greeting only if name is not null.

Kotlin

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

This does nothing because age is null.

Kotlin

val age: Int? = null
age?.let { println("Age is $it") }

This extracts and prints the email domain if email is not null.

Kotlin

val email: String? = "[e-mail]"
email?.let {
    val domain = it.substringAfter("@")
    println("Email domain: $domain")
}

Sample Program

This program prints the user name only if it is not null. It skips printing the city because it is null.

Kotlin

fun main() {
    val userName: String? = "Bob"
    val userCity: String? = null

    userName?.let { println("User name is $it") }
    userCity?.let { println("User city is $it") }
}

Important Notes

If the variable is null, the code inside let will not run.

You can use it inside let to refer to the non-null value.

This helps avoid errors called NullPointerException in Kotlin.

Summary

let with safe calls runs code only when a value is not null.

Use ?.let { } to safely work with nullable variables.

This keeps your code safe and clean by avoiding null errors.

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