Apply function behavior and use cases in Kotlin - Step-by-Step Execution

Concept Flow - Apply function behavior and use cases

Start with an object

↓

Call apply on object

↓

Inside apply: execute block with 'this' as object

↓

Modify object properties

↓

Return the original object

↓

Use modified object

The apply function runs a block on an object, lets you modify it using 'this', and returns the same object for chaining.

Execution Sample

Kotlin

val person = Person().apply {
    name = "Alice"
    age = 30
}
println(person)

Creates a Person, sets name and age inside apply, then prints the modified person.

Execution Table

Step	Action	Object State (name, age)	Return Value	Output
1	Create Person object	name=null, age=0	Person instance
2	Enter apply block	name=null, age=0	Person instance
3	Set name = "Alice"	name=Alice, age=0	Person instance
4	Set age = 30	name=Alice, age=30	Person instance
5	Exit apply block	name=Alice, age=30	Person instance
6	Print person	name=Alice, age=30	Person instance	Person(name=Alice, age=30)

💡 apply returns the original object after executing the block, allowing property changes.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
person.name	null	Alice	Alice	Alice
person.age	0	0	30	30

Key Moments - 2 Insights

Why does apply return the original object and not the block's last expression?

Because apply is designed to return the object it was called on, enabling chaining. See execution_table step 5 where return value is the Person instance, not the last assignment.

How does 'this' work inside the apply block?

Inside apply, 'this' refers to the object, so you can set properties directly without naming the object. See execution_table steps 3 and 4 where name and age are set without prefix.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of person.age?

A 0

B 30

C null

D Unchanged

💡 Hint

Check the Object State column at step 4 in execution_table.

At which step does apply return the original object?

A Step 3

B Step 6

C Step 5

D Step 2

💡 Hint

Look at the Return Value column in execution_table.

If you replaced apply with let, what would change in the return value?

A Return value would be the last expression in the block

B Return value would be the original object

C Return value would be null

D Return value would be Unit

💡 Hint

Recall that apply returns the object, but let returns the block result.

Concept Snapshot

apply function syntax:
object.apply { this.property = value; ... }
- Executes block with 'this' as object
- Returns the original object
- Useful for initializing or modifying objects inline
- Enables chaining after modifications

Full Transcript

The apply function in Kotlin lets you run a block of code on an object, using 'this' to refer to it. Inside the block, you can set or change properties easily. After the block finishes, apply returns the same object, not the block's last expression. This helps you write clean code to create and modify objects in one step. For example, creating a Person and setting name and age inside apply, then printing the person shows the updated values. Remember, apply returns the original object, so you can chain calls. This is different from let, which returns the block's result.

Practice

1. What does the apply function do in Kotlin?

easy

A. Runs code on an object and returns the same object

B. Creates a new object and returns it

C. Runs code and returns the last expression result

D. Runs code without returning anything

Solution

1. Step 1: Understand the purpose of apply

   The apply function executes a block of code on the object it is called on.

2. Step 2: Identify the return value of apply

   It always returns the original object after applying the block, not a new value.

3. Final Answer:

   Runs code on an object and returns the same object -> Option A

4. Quick Check:

   apply returns the object itself [OK]

Hint: Remember: apply returns the original object after changes [OK]

Common Mistakes:

• Thinking apply returns the last expression result
• Confusing apply with let or run
• Assuming apply creates a new object

2. Which of the following is the correct syntax to use apply on an object person to set its name property to "Alice"?

easy

A. person.apply { name = "Alice" }

B. apply(person) { name = "Alice" }

C. person.apply(name = "Alice")

D. person.apply { setName("Alice") }

Solution

1. Step 1: Identify the correct lambda syntax for apply

   apply takes a lambda with receiver where this is the object, so properties can be set directly.

2. Step 2: Check each option's syntax

   person.apply { name = "Alice" } correctly uses person.apply { name = "Alice" }. apply(person) { name = "Alice" } is invalid syntax. person.apply(name = "Alice") wrongly passes a parameter. person.apply { setName("Alice") } assumes a setter method which may not exist.

3. Final Answer:

   person.apply { name = "Alice" } -> Option A

4. Quick Check:

   Use object.apply { property = value } syntax [OK]

Hint: Use curly braces with apply to set properties inside [OK]

Common Mistakes:

• Passing parameters directly to apply
• Using parentheses instead of curly braces
• Calling non-existent setter methods

3. What is the output of this Kotlin code?

val list = mutableListOf<Int>().apply {
    add(1)
    add(2)
    add(3)
}
println(list)

medium

A. Compilation error

B. []

C. null

D. [1, 2, 3]

Solution

1. Step 1: Understand what apply does on the list

   The apply block adds 1, 2, and 3 to the mutable list.

2. Step 2: Check the returned value of apply

   apply returns the original list after adding the elements, so list contains [1, 2, 3].

3. Final Answer:

   [1, 2, 3] -> Option D

4. Quick Check:

   apply adds elements and returns the list [OK]

Hint: apply returns the object after running code inside [OK]

Common Mistakes:

• Expecting apply to return last added element
• Thinking list is empty after apply
• Confusing apply with run or let

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

val map = mutableMapOf()
map.apply {
    put("a", 1)
    put("b", 2)
}
println(map.get("c"))

medium

A. Syntax error in apply block

B. Compilation error due to missing return

C. No error; output is null

D. Runtime error: key "c" not found

Solution

1. Step 1: Check the apply block usage

   The apply block correctly adds two entries to the map.

2. Step 2: Understand the map.get("c") call

   Since key "c" does not exist, get returns null, which is printed without error.

3. Final Answer:

   No error; output is null -> Option C

4. Quick Check:

   Accessing missing key returns null, no error [OK]

Hint: Missing keys in map.get return null, no crash [OK]

Common Mistakes:

• Expecting runtime error for missing key
• Thinking apply must return a value explicitly
• Confusing map access syntax

5. You want to create and configure a StringBuilder in Kotlin to build the string "Hello World!" using apply. Which code snippet correctly does this?

hard

A. val result = StringBuilder().apply { append("Hello"); append(" World!") }

B. val result = StringBuilder().apply { append("Hello"); append(" World!") }.toString()

C. val result = StringBuilder().apply { append("Hello World!") }

D. val result = StringBuilder().apply { append("Hello"); append(" World!") }.toString

Solution

1. Step 1: Understand apply returns the object itself

   The apply block configures the StringBuilder, but to get the string, toString() must be called after.

2. Step 2: Check each option's correctness

   val result = StringBuilder().apply { append("Hello"); append(" World!") }.toString() calls toString() after apply, returning the built string. val result = StringBuilder().apply { append("Hello World!") } returns the StringBuilder object, not the string. val result = StringBuilder().apply { append("Hello"); append(" World!") } misses toString(). val result = StringBuilder().apply { append("Hello"); append(" World!") }.toString misses parentheses on toString, causing error.

3. Final Answer:

   val result = StringBuilder().apply { append("Hello"); append(" World!") }.toString() -> Option B

4. Quick Check:

   Call toString() after apply to get string [OK]

Hint: Call toString() after apply to get final string [OK]

Common Mistakes:

• Forgetting to call toString() after apply
• Missing parentheses on toString
• Expecting apply to return string automatically