Terminal operations trigger execution in Kotlin - Mini Project: Build & Apply

Terminal Operations Trigger Execution in Kotlin Sequences

📖 Scenario: You are managing a list of book titles in a library system. You want to filter and process these titles efficiently using Kotlin sequences, which delay execution until a terminal operation is called.

🎯 Goal: Build a Kotlin program that creates a sequence of book titles, configures a filter condition, applies the filter using a sequence operation, and finally triggers execution with a terminal operation.

📋 What You'll Learn

Create a sequence of book titles with exact values

Add a filter condition variable for minimum title length

Use a sequence filter operation with the condition variable

Trigger execution using a terminal operation to collect results

💡 Why This Matters

🌍 Real World

Sequences in Kotlin are used to efficiently process large or infinite data streams by delaying execution until results are needed, saving memory and CPU.

💼 Career

Understanding how terminal operations trigger execution in sequences is important for Kotlin developers working on performance-sensitive applications, such as mobile apps or backend services.

1

Create a sequence of book titles

Create a Kotlin val named bookTitles that is a sequence containing these exact strings in this order: "Kotlin Basics", "Advanced Kotlin", "Database Design", "Android Development", "Coroutines".

Kotlin

# Create a sequence called bookTitles with the given book titles
// Your code here

Hint

Use sequenceOf() to create a sequence with the exact book titles listed.

2

Add a filter condition variable

Create a Kotlin val named minTitleLength and set it to the integer 15. This will be used to filter book titles by length.

Kotlin

val bookTitles = sequenceOf("Kotlin Basics", "Advanced Kotlin", "Database Design", "Android Development", "Coroutines")
// Create a val minTitleLength and set it to 15
// Your code here

Hint

Define minTitleLength as an integer value 15.

3

Apply filter operation on the sequence

Create a Kotlin val named longTitles that filters bookTitles to include only titles whose length is greater than or equal to minTitleLength. Use the filter sequence operation with a lambda that checks it.length >= minTitleLength.

Kotlin

val bookTitles = sequenceOf("Kotlin Basics", "Advanced Kotlin", "Database Design", "Android Development", "Coroutines")
val minTitleLength = 15
// Create a val longTitles by filtering bookTitles with length >= minTitleLength
// Your code here

Hint

Use filter on bookTitles with a lambda checking it.length >= minTitleLength.

4

Trigger execution with a terminal operation

Create a Kotlin val named resultList that collects the filtered sequence longTitles into a list by calling the terminal operation toList().

Kotlin

val bookTitles = sequenceOf("Kotlin Basics", "Advanced Kotlin", "Database Design", "Android Development", "Coroutines")
val minTitleLength = 15
val longTitles = bookTitles.filter { it.length >= minTitleLength }
// Collect longTitles into a list called resultList using toList()
// Your code here

Hint

Call toList() on longTitles to trigger execution and collect results.

Practice

1. What does a terminal operation do in Kotlin sequences or collections?
toList(), count(), and forEach() are examples of terminal operations. What is their main role?

easy

A. They start the actual processing and produce results or side effects.

B. They define the data source without processing it.

C. They create new sequences without executing any code.

D. They only prepare the data but do not execute any operation.

Solution

1. Step 1: Understand what terminal operations are

   Terminal operations are the final step in a sequence or collection processing chain that triggers execution.

2. Step 2: Identify the role of examples like toList(), count(), and forEach()

   These operations produce a result or cause side effects, thus starting the actual processing.

3. Final Answer:

   They start the actual processing and produce results or side effects. -> Option A

4. Quick Check:

   Terminal operations trigger execution = B [OK]

Hint: Terminal operations always trigger execution and produce results [OK]

Common Mistakes:

• Thinking terminal operations only prepare data without running it
• Confusing terminal operations with intermediate operations
• Believing terminal operations do not produce results

2. Which of the following is a correct Kotlin terminal operation syntax on a list named numbers?

easy

A. numbers.toList()

B. numbers.map()

C. numbers.filter()

D. numbers.sortedBy

Solution

1. Step 1: Identify terminal operations syntax

   Terminal operations like toList() are called with parentheses to execute and produce results.

2. Step 2: Check each option

   map() and filter() are intermediate operations requiring arguments; sortedBy is incomplete without parentheses.

3. Final Answer:

   numbers.toList() -> Option A

4. Quick Check:

   Correct terminal operation syntax = A [OK]

Hint: Terminal operations have parentheses and produce results [OK]

Common Mistakes:

• Using intermediate operations as terminal without arguments
• Omitting parentheses on function calls
• Confusing intermediate and terminal operations

3. Consider this Kotlin code:

val numbers = sequenceOf(1, 2, 3, 4)
val result = numbers.filter { it % 2 == 0 }.count()

What is the value of result after execution?

medium

A. 0

B. 4

C. 2

D. Sequence<Int>

Solution

1. Step 1: Apply the filter condition

   The filter keeps only even numbers: 2 and 4.

2. Step 2: Count the filtered elements

   There are 2 even numbers, so count() returns 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Count of even numbers = 2 [OK]

Hint: Filter then count gives number of matching elements [OK]

Common Mistakes:

• Counting before filtering
• Assuming count returns the sequence itself
• Confusing sequence with list output

4. What is wrong with this Kotlin code snippet?

val numbers = listOf(1, 2, 3)
numbers.filter { it > 1 }

Why does it not print or return any filtered list?

medium

A. The variable numbers is immutable.

B. Missing a terminal operation to trigger execution.

C. List cannot be filtered in Kotlin.

D. The filter condition is invalid syntax.

Solution

1. Step 1: Understand filter is intermediate

   The filter function returns a new list but does not execute anything by itself.

2. Step 2: Identify missing terminal operation

   Without a terminal operation like toList() or forEach(), the filtered list is not processed or printed.

3. Final Answer:

   Missing a terminal operation to trigger execution. -> Option B

4. Quick Check:

   Intermediate operations need terminal to run = D [OK]

Hint: Always end with terminal operation to see results [OK]

Common Mistakes:

• Thinking filter runs immediately
• Assuming immutability blocks filtering
• Believing filter syntax is wrong

5. Given this Kotlin code:

val data = sequenceOf(0, 1, 2, 3, 4, 5)
val result = data
  .filter { it > 0 }
  .map { if (it % 2 == 0) it * 10 else it }
  .toList()

What is the content of result after execution?

hard

A. [10, 20, 30, 40, 50]

B. [0, 1, 2, 3, 4, 5]

C. [1, 2, 3, 4, 5]

D. [1, 20, 3, 40, 5]

Solution

1. Step 1: Filter out values greater than 0

   Sequence after filter: 1, 2, 3, 4, 5 (0 is removed).

2. Step 2: Map even numbers to value * 10, odd numbers unchanged

   1 (odd) -> 1, 2 (even) -> 20, 3 (odd) -> 3, 4 (even) -> 40, 5 (odd) -> 5.

3. Step 3: Convert sequence to list with toList()

   Final list: [1, 20, 3, 40, 5].

4. Final Answer:

   [1, 20, 3, 40, 5] -> Option D

5. Quick Check:

   Filter then map then toList = C [OK]

Hint: Filter first, then map, then terminal operation to get result [OK]

Common Mistakes:

• Forgetting filter removes 0
• Mapping all numbers instead of only even
• Missing toList() to trigger execution