Flow builder and collect in Kotlin - Step-by-Step Execution

Concept Flow - Flow builder and collect

Start Flow Builder

↓

Emit values one by one

↓

Flow created

↓

Call collect on Flow

↓

Collect each emitted value

↓

Process or print value

↓

End when all values emitted

The flow builder creates a flow that emits values one by one. When collect is called, it receives each value and processes it until all are emitted.

Execution Sample

Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val flow = flow {
        emit(1)
        emit(2)
        emit(3)
    }
    flow.collect { value ->
        println(value)
    }
}

This code creates a flow that emits numbers 1, 2, and 3, then collects and prints each number.

Execution Table

Step	Action	Flow State	Collected Value	Output
1	Start flow builder	Flow created, no values emitted yet	None	None
2	Emit 1	Flow emits 1	1	Print 1
3	Emit 2	Flow emits 2	2	Print 2
4	Emit 3	Flow emits 3	3	Print 3
5	Flow completes	No more values	None	Collection ends

💡 All values emitted and collected, flow completes

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
flow	empty	emitted 1	emitted 2	emitted 3	completed
value	none	1	2	3	none

Key Moments - 2 Insights

Why does collect receive values one by one instead of all at once?

Because the flow emits values sequentially and collect processes each emitted value immediately, as shown in execution_table rows 2 to 4.

What happens if we don't call collect on the flow?

The flow builder creates the flow but no values are emitted or processed until collect is called, so nothing happens (see execution_table step 1 vs steps 2-5).

Visual Quiz - 3 Questions

Look at the execution table, what is the collected value at step 3?

A 1

B 2

C 3

D None

💡 Hint

Check the 'Collected Value' column at step 3 in the execution_table.

At which step does the flow complete and stop emitting values?

A Step 5

B Step 3

C Step 4

D Step 2

💡 Hint

Look for the step where 'Flow completes' is noted in the 'Action' column.

If we remove the collect call, what changes in the execution?

A Values are emitted but not collected

B Flow emits and collects automatically

C No values are emitted or collected

D Values are collected but not emitted

💡 Hint

Refer to key_moments about what happens if collect is not called.

Concept Snapshot

Flow builder creates a flow that emits values sequentially.
Use emit(value) inside flow { } to send values.
Call collect { value -> ... } to receive and process each emitted value.
Without collect, flow does not emit values.
Collect runs suspending and processes values one by one.

Full Transcript

In Kotlin, a flow builder creates a flow that emits values one at a time using emit(). When you call collect on the flow, it receives each emitted value and processes it, for example by printing. The flow completes after all values are emitted. If you don't call collect, the flow does not emit any values. This step-by-step trace shows how values 1, 2, and 3 are emitted and collected in order.

Practice

1. What is the primary purpose of the flow {} builder in Kotlin?

easy

A. To create a stream of values that can be emitted over time

B. To immediately execute a block of code and return a single value

C. To collect values from a list synchronously

D. To define a suspend function without any emissions

Solution

1. Step 1: Understand the role of flow {}

   The flow {} builder creates a stream that can emit multiple values asynchronously over time.

2. Step 2: Compare with other options

   Options B, C, and D describe synchronous or non-stream behaviors, which do not match flow {} usage.

3. Final Answer:

   To create a stream of values that can be emitted over time -> Option A

4. Quick Check:

   Flow builder = stream of values [OK]

Hint: Remember: flow builds streams, not single immediate values [OK]

Common Mistakes:

• Confusing flow with suspend functions returning single values
• Thinking flow collects values instead of emitting them
• Assuming flow is synchronous

2. Which of the following is the correct syntax to collect values from a flow named myFlow inside a suspend function?

easy

A. myFlow.collect(value -> println(value))

B. myFlow.collect { println(value) }

C. myFlow.collect { value -> println(value) }

D. myFlow.collect { value => println(value) }

Solution

1. Step 1: Identify correct lambda syntax in Kotlin

   Kotlin uses curly braces with parameter and arrow: { param -> action }.

2. Step 2: Match syntax with options

   myFlow.collect { value -> println(value) } correctly uses { value -> println(value) }. Options A lacks braces, B misses parameter declaration (value undefined), D uses wrong arrow symbol (=>).

3. Final Answer:

   myFlow.collect { value -> println(value) } -> Option C

4. Quick Check:

   Correct lambda syntax = myFlow.collect { value -> println(value) } [OK]

Hint: Use { param -> action } syntax for Kotlin lambdas [OK]

Common Mistakes:

• Omitting lambda parameter name
• Using Java-style arrows (->) incorrectly
• Using parentheses instead of curly braces

3. What will be the output of the following Kotlin code?

import kotlinx.coroutines.flow.*
suspend fun main() {
    val numbers = flow {
        emit(1)
        emit(2)
        emit(3)
    }
    numbers.collect { println(it * 2) }
}

medium

A. 1
2
3

B. 2
4
6

C. 3
6
9

D. Compilation error

Solution

1. Step 1: Analyze emitted values

   The flow emits 1, 2, and 3 sequentially.

2. Step 2: Understand the collect block

   Each emitted value is multiplied by 2 and printed, so outputs are 2, 4, and 6.

3. Final Answer:

   2 4 6 -> Option B

4. Quick Check:

   Emitted values * 2 = 2,4,6 [OK]

Hint: Multiply emitted values inside collect to get output [OK]

Common Mistakes:

• Printing original values without multiplication
• Expecting a list output instead of separate prints
• Assuming compilation error due to missing coroutine context

4. Identify the error in this Kotlin flow code snippet:

val flow = flow {
    emit(1)
    emit(2)
}
flow.collect { println(it) }

medium

A. collect should be called with parentheses

B. Incorrect flow builder syntax

C. emit cannot be called inside flow builder

D. Missing suspend modifier on the function calling collect

Solution

1. Step 1: Check flow and collect usage

   The flow builder and emit calls are correct.

2. Step 2: Understand collect context

   Collect is a suspend function and must be called from a suspend function or coroutine scope. Calling it directly without suspend context causes error.

3. Final Answer:

   Missing suspend modifier on the function calling collect -> Option D

4. Quick Check:

   collect requires suspend context [OK]

Hint: Remember: collect is suspend, needs suspend function or coroutine [OK]

Common Mistakes:

• Trying to call collect outside suspend or coroutine
• Confusing emit usage inside flow
• Thinking collect syntax is wrong

5. You want to create a flow that emits only even numbers from 1 to 5 and then collect and print them. Which code snippet correctly achieves this?

hard

A. val flow = flow {
for (i in 1..5) {
if (i % 2 == 0) emit(i)
}
}
suspend fun main() {
flow.collect { println(it) }
}

B. val flow = flowOf(1, 2, 3, 4, 5).filter { it % 2 == 0 }
fun main() {
flow.collect { println(it) }
}

C. val flow = flow {
emit(2)
emit(4)
}
flow.collect { println(it) }

D. val flow = flow {
for (i in 1..5) emit(i)
}
flow.collect { if (it % 2 == 0) println(it) }

Solution

1. Step 1: Check flow emission of even numbers

   val flow = flow { for (i in 1..5) { if (i % 2 == 0) emit(i) } } suspend fun main() { flow.collect { println(it) } } emits only even numbers inside the flow builder using a for loop and condition.

2. Step 2: Verify collection and printing

   val flow = flow { for (i in 1..5) { if (i % 2 == 0) emit(i) } } suspend fun main() { flow.collect { println(it) } } collects the flow inside a suspend function and prints each emitted value correctly.

3. Final Answer:

   val flow = flow { for (i in 1..5) { if (i % 2 == 0) emit(i) } } suspend fun main() { flow.collect { println(it) } } -> Option A

4. Quick Check:

   Emit filtered values inside flow, collect in suspend [OK]

Hint: Filter inside flow builder to emit only needed values [OK]

Common Mistakes:

• Calling collect outside suspend function
• Filtering after emitting all values instead of inside flow
• Not using suspend function for collect