Why Flow matters for async sequences in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Flow code?

Consider this Kotlin Flow code that emits numbers with delay. What will be printed?

Kotlin

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

fun main() = runBlocking {
    val flow = flow {
        for (i in 1..3) {
            delay(100)
            emit(i)
        }
    }
    flow.collect { value ->
        println("Received $value")
    }
}

A Received 1\nReceived 2\nReceived 3

B Received 3\nReceived 2\nReceived 1

C Received 1\nReceived 1\nReceived 1

D No output, program hangs

💡 Hint

Flow emits values sequentially with delay, collect prints each as it arrives.

The flow emits numbers 1 to 3 with a delay of 100ms each. The collect function prints each value as it is emitted, so the output is Received 1, then 2, then 3 in order.

🧠 Conceptual

intermediate

Why use Flow instead of a simple suspend function returning a list?

Which reason best explains why Kotlin Flow is preferred for asynchronous sequences over a suspend function that returns a full list?

A Flow always runs on the main thread, making UI updates easier.

B Suspend functions cannot return lists in Kotlin.

C Flow emits values one by one asynchronously, allowing processing before all data is ready.

D Suspend functions are slower than Flow in all cases.

💡 Hint

Think about how data arrives and is processed over time.

Flow allows emitting values one at a time asynchronously, so consumers can start processing early without waiting for the entire list. Suspend functions returning lists wait until all data is ready.

🔧 Debug

advanced

What error does this Flow code produce?

This Kotlin code tries to collect from a Flow but crashes. What error is thrown?

Kotlin

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

fun main() = runBlocking {
    val flow = flow {
        emit(1)
        throw RuntimeException("Oops")
    }
    flow.collect { value ->
        println(value)
    }
}

A No error, prints 1 then stops

B NullPointerException

C Compilation error: missing catch block

D RuntimeException with message 'Oops'

💡 Hint

Look at what happens after emitting the first value.

The flow emits 1, then throws a RuntimeException. The collect call propagates this exception, causing the program to crash with that error.

📝 Syntax

advanced

Which option correctly creates a Flow emitting squares of 1 to 3?

Choose the Kotlin code snippet that correctly creates a Flow emitting 1, 4, 9.

A flow { (1..3).map { emit(it * it) } }

B flow { for (i in 1..3) emit(i * i) }

C flow { for i in 1..3 emit(i * i) }

D flow { emit(i * i) for i in 1..3 }

💡 Hint

Remember Kotlin syntax for loops and emit inside flow builder.

Option B uses correct Kotlin syntax: a for loop inside flow builder with emit calls. Other options have syntax errors or misuse map.

🚀 Application

expert

How many items does this Flow emit before cancellation?

Given this Kotlin Flow code with cancellation, how many values are printed before the program stops?

Kotlin

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

fun main() = runBlocking {
    val flow = flow {
        var i = 1
        while (true) {
            emit(i++)
            delay(50)
        }
    }
    val job = launch {
        flow.collect { value ->
            println(value)
            if (value == 3) cancel()
        }
    }
    job.join()
}

A 3

B 4

C Infinite, program never stops

D 2

💡 Hint

Look when cancellation happens inside collect.

The flow emits values starting from 1. When value 3 is received, the coroutine cancels itself, so exactly 3 values are printed.