Chaining scope functions in Kotlin

Introduction

Chaining scope functions helps you write clear and short code by running many actions on the same object in a row.

When you want to change or use an object several times without repeating its name.

When you want to set up or configure an object step-by-step in a clean way.

When you want to perform multiple operations on an object and return the final result.

When you want to avoid temporary variables and keep code readable.

When you want to combine actions like modifying, printing, and returning an object smoothly.

Syntax

Kotlin

val result = object.scopeFunction1 {
    // first block using 'this' or 'it'
}.scopeFunction2 {
    // second block
}.scopeFunction3 {
    // third block
}

Scope functions like let, run, also, apply, and with can be chained.

Each function passes the object or the last result to the next, so you can do many things in one expression.

Examples

This example changes text to uppercase, prints it, then reverses it.

Kotlin

val text = "hello"

val result = text
    .let { it.uppercase() }
    .also { println("Uppercase: $it") }
    .let { it.reversed() }

println(result)

This example doubles a number, prints it, then adds 3.

Kotlin

val number = 5

val result = number
    .run { this * 2 }
    .also { println("Doubled: $it") }
    .run { this + 3 }

println(result)

This example adds and removes items from a list, printing after each change.

Kotlin

val list = mutableListOf(1, 2, 3)

list
    .apply { add(4) }
    .also { println("List after add: $it") }
    .apply { removeAt(0) }
    .also { println("List after remove: $it") }

This example checks if a string is empty and prints a message.

Kotlin

val emptyString = ""

val result = emptyString
    .let { if (it.isEmpty()) "Empty" else it }
    .also { println(it) }

Sample Program

This program creates a person, increases their age, prints the updated person, then changes the name to uppercase and prints the final result.

Kotlin

fun main() {
    val person = Person("Alice", 25)

    val updatedPerson = person
        .apply { age += 1 } // Increase age by 1
        .also { println("After birthday: $it") } // Print person
        .run {
            copy(name = name.uppercase()) // Change name to uppercase
        }

    println("Final person: $updatedPerson")
}

data class Person(var name: String, var age: Int)

Important Notes

Time complexity depends on the operations inside each scope function, but chaining itself is very fast.

Space complexity is low since no extra large data structures are created during chaining.

A common mistake is confusing which scope function returns the original object and which returns a transformed result.

Use apply or also when you want to return the original object after changes.

Use let or run when you want to return a new value after transformations.

Summary

Chaining scope functions lets you do many things on one object in a clean, readable way.

Different scope functions return either the original object or a new result, so choose based on what you want to get back.

Use chaining to avoid repeating object names and keep your code short and clear.

Practice

1. What does chaining scope functions in Kotlin help you achieve?

easy

A. Perform multiple operations on one object without repeating its name

B. Create multiple objects at once

C. Write loops faster

D. Automatically convert types

Solution

1. Step 1: Understand the purpose of scope functions

   Scope functions let you run code blocks on an object, often returning the object or a result.

2. Step 2: Recognize chaining benefit

   Chaining lets you call many scope functions one after another on the same object without repeating its name.

3. Final Answer:

   Perform multiple operations on one object without repeating its name -> Option A

4. Quick Check:

   Chaining scope functions = clean, repeated operations [OK]

Hint: Chaining avoids repeating object names in multiple calls [OK]

Common Mistakes:

• Thinking chaining creates new objects
• Confusing chaining with loops
• Believing chaining changes data types automatically

2. Which of the following is the correct syntax to chain apply and also on an object obj?

easy

A. obj.apply { }.also { }

B. obj.apply() also()

C. apply(obj) { } also { }

D. obj.apply { } also { }

Solution

1. Step 1: Recall correct chaining syntax

   In Kotlin, scope functions are called with dot notation and lambda blocks inside curly braces.

2. Step 2: Check each option

   obj.apply { }.also { } uses correct dot chaining with braces. obj.apply() also() misses dots and braces. apply(obj) { } also { } uses wrong function call style. obj.apply { } also { } misses dot before also.

3. Final Answer:

   obj.apply { }.also { } -> Option A

4. Quick Check:

   Dot + braces = correct chaining syntax [OK]

Hint: Use dot and braces for each scope function call [OK]

Common Mistakes:

• Omitting dots between functions
• Using parentheses instead of braces for lambdas
• Calling scope functions like regular functions without object

3. What is the output of this Kotlin code?

val result = "hello".also { println(it.uppercase()) }.length
println(result)

medium

A. hello\n5

B. 5\nHELLO

C. HELLO\nhello

D. HELLO\n5

Solution

1. Step 1: Understand also behavior

   also runs the lambda with the object as it, prints uppercase "HELLO", then returns the original string "hello".

2. Step 2: Calculate result

   After also, length is called on "hello", which is 5. Then println(result) prints 5.

3. Final Answer:

   HELLO 5 -> Option D

4. Quick Check:

   also prints uppercase, length returns 5 [OK]

Hint: also returns original object, so length is on original string [OK]

Common Mistakes:

• Thinking also returns uppercase string
• Confusing print order
• Expecting length to be printed before uppercase

4. Find the error in this Kotlin code chaining scope functions:

val text = "kotlin"
text.let { it.uppercase() }.apply { println(this) }

medium

A. apply cannot be called after let because let returns a different type

B. Missing lambda braces in apply

C. let does not return the original object, so apply prints wrong value

D. No error, code works fine

Solution

1. Step 1: Analyze let return value

   let returns the lambda result, here it.uppercase(), a new String "KOTLIN".

2. Step 2: Check apply receiver

   apply is called on the uppercase string, so this inside apply is "KOTLIN" and println(this) prints "KOTLIN".

3. Step 3: Identify the problem

   The original text is "kotlin", but apply prints the uppercase string, not the original. This may be unexpected if you want to print original.

4. Final Answer:

   let does not return the original object, so apply prints wrong value -> Option C

5. Quick Check:

   let returns lambda result, not original object [OK]

Hint: Remember let returns lambda result, not original object [OK]

Common Mistakes:

• Assuming let returns original object
• Thinking apply needs braces
• Believing no error exists

5. Given a mutable list val nums = mutableListOf(1, 2, 3), which chained scope function call correctly adds 4, prints the list, and returns the updated list?

hard

A. nums.let { it.add(4) }.also { println(it) }

B. nums.apply { add(4) }.also { println(it) }

C. nums.also { add(4) }.apply { println(this) }

D. nums.run { add(4); println(this) }

Solution

1. Step 1: Understand return values of scope functions

   apply returns the original object after running the block, also returns the original object too, let returns lambda result, run returns lambda result.

2. Step 2: Check each option

   nums.apply { add(4) }.also { println(it) } adds 4 inside apply, then prints list in also, returning the updated list. nums.let { it.add(4) }.also { println(it) }'s let returns Unit from add, so also prints Unit. nums.also { add(4) }.apply { println(this) } has syntax error ('add' unresolved in also block, needs it.add(4)). nums.run { add(4); println(this) } returns Unit from run.

3. Final Answer:

   nums.apply { add(4) }.also { println(it) } -> Option B

4. Quick Check:

   apply returns object, also prints it [OK]

Hint: Use apply to modify and also to print, both return original object [OK]

Common Mistakes:

• Using let which returns Unit from add
• Expecting run to return the list
• Confusing order of operations in chaining