Run function behavior and use cases in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the primary purpose of the run function in Kotlin?

The run function executes a block of code and returns the result of the last expression inside that block. It is often used to execute code in a scoped way and return a value.

intermediate

How does run differ from let in Kotlin?

run does not provide the object as a parameter inside the block, instead it uses this as the context. let passes the object as an argument named it. run is useful for executing code blocks without needing the object explicitly.

beginner

What is the return value of the run function?

The return value of run is the value of the last expression inside its lambda block.

beginner

Show a simple example of using run to initialize and return a value.

Example:

val result = run {
    val x = 10
    val y = 20
    x + y // last expression returned
}
// result is 30

intermediate

When is it useful to use run in Kotlin?

Use run when you want to execute multiple statements in a block and return a result, especially when you want to limit the scope of variables or avoid repeating the object name.

What does the Kotlin run function return?

A The last expression inside its block

B The object it was called on

C Always null

D A Boolean value

run returns the value of the last expression inside its lambda block.

Which keyword represents the context object inside a run block?

A it

B self

C this

D obj

Inside run, this refers to the context object, unlike let which uses it.

Which of these is a typical use case for run?

A To execute a block and return a value

B To create a new thread

C To handle exceptions

D To declare a variable

run is used to execute a block of code and return the last expression's value.

How does run differ from apply?

A <code>run</code> returns the object, <code>apply</code> returns the last expression

B <code>run</code> returns the last expression, <code>apply</code> returns the object

C Both return the object

D Both return the last expression

run returns the last expression inside the block, while apply returns the object it was called on.

What is the scope of variables declared inside a run block?

A Global scope

B Outside the block

C Class level

D Only inside the <code>run</code> block

Variables declared inside run are local to that block and cannot be accessed outside.

Explain how the run function works in Kotlin and when you would use it.

Think about how run helps organize code and return results.

Describe the difference between run and let in Kotlin.

Focus on how the object is accessed inside the lambda.

Practice

1. What does the Kotlin run function do when called without an object?

easy

A. Creates a new thread to run the block asynchronously

B. Delays the execution of the block until explicitly called

C. Executes the given block and returns the last expression's value

D. Throws an exception if the block contains no return statement

Solution

1. Step 1: Understand run without receiver

   When run is called without an object, it simply executes the block of code inside it.

2. Step 2: Identify the return value

   The function returns the value of the last expression inside the block.

3. Final Answer:

   Executes the given block and returns the last expression's value -> Option C

4. Quick Check:

   run without object returns last expression [OK]

Hint: run returns last expression value in its block [OK]

Common Mistakes:

• Thinking run creates a new thread
• Assuming run delays execution
• Believing run throws error without explicit return

2. Which of the following is the correct syntax to use run with an object in Kotlin?

easy

A. val result = run.obj { property + 1 }

B. val result = obj.run { this.property + 1 }

C. val result = run { obj.property + 1 }

D. val result = obj.run() { property + 1 }

Solution

1. Step 1: Identify correct run usage with receiver

   The run function is called as an extension on the object: obj.run { ... }.

2. Step 2: Check syntax correctness

   val result = obj.run { this.property + 1 } correctly uses obj.run { this.property + 1 } without extra parentheses or misplaced dots.

3. Final Answer:

   val result = obj.run { this.property + 1 } -> Option B

4. Quick Check:

   run called as extension function on object [OK]

Hint: run is called as extension: obj.run { ... } [OK]

Common Mistakes:

• Using dot after run like run.obj
• Adding empty parentheses after run
• Calling run without object but expecting receiver

3. What is the output of this Kotlin code?

val result = run {
    val x = 5
    val y = 10
    x + y
}
println(result)

medium

A. Compilation error

B. 510

C. null

D. 15

Solution

1. Step 1: Execute the run block

   The block declares x = 5 and y = 10, then returns x + y which is 15.

2. Step 2: Print the result

   The variable result holds 15, so println(result) outputs 15.

3. Final Answer:

   15 -> Option D

4. Quick Check:

   run returns last expression value 15 [OK]

Hint: run returns last expression value inside block [OK]

Common Mistakes:

• Concatenating numbers as strings
• Expecting null because no explicit return
• Thinking run causes compilation error

4. Identify the error in this Kotlin code using run:

val text = "Hello"
val length = text.run {
    val len = length
}
println(length)

medium

A. The run block does not return a value, so length is assigned Unit

B. The variable len is not accessible outside run block

C. The property length is undefined for String

D. The run function cannot be called on a String

Solution

1. Step 1: Analyze run block return

   The run block declares val len = length but does not return any expression explicitly, so it returns Unit.

2. Step 2: Check assignment to length variable

   Variable length is assigned the result of run, which is Unit, not the integer length of the string.

3. Final Answer:

   The run block does not return a value, so length is assigned Unit -> Option A

4. Quick Check:

   run returns last expression; no explicit return means Unit [OK]

Hint: run returns last expression; no explicit return means Unit [OK]

Common Mistakes:

• Assuming len is returned automatically
• Confusing property length with variable
• Thinking run cannot be called on String

5. Given a list of nullable integers val numbers = listOf(1, null, 3, null, 5), how can you use run to compute the sum of non-null values safely in Kotlin?

hard

A. val sum = numbers.run { filterNotNull().sum() }

B. val sum = run(numbers) { filterNotNull().sum() }

C. val sum = numbers.run { sum() }

D. val sum = run { filterNotNull().sum() }

Solution

1. Step 1: Use run as extension on list

   Calling numbers.run { ... } lets you access list functions directly inside the block.

2. Step 2: Filter non-null and sum

   Inside the block, filterNotNull() removes nulls, then sum() adds remaining numbers.

3. Final Answer:

   val sum = numbers.run { filterNotNull().sum() } -> Option A

4. Quick Check:

   run with receiver simplifies code, returns last expression [OK]

Hint: Use run as extension to chain calls on object [OK]

Common Mistakes:

• Passing list as argument to run incorrectly
• Calling sum() without filtering nulls
• Using run without receiver and accessing list members directly