Flow exception handling in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin Flow exception handling code?

Consider the following Kotlin code using flow and catch. What will be printed?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        emit(2)
        throw RuntimeException("Error in flow")
    }
    .catch { e -> emit(-1) }
    .collect { value -> println(value) }
}

A

1
2

B

1
2
-1

C

1
-1

D

1
2
Exception in thread "main" java.lang.RuntimeException: Error in flow

💡 Hint

The catch operator catches exceptions and can emit fallback values.

The flow emits 1 and 2, then throws an exception. The catch block catches it and emits -1. So the output is 1, 2, -1.

❓ Predict Output

intermediate

What error does this Kotlin Flow code raise?

What error will this Kotlin code produce when run?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        throw IllegalStateException("Oops")
    }
    .collect { value ->
        if (value == 1) throw ArithmeticException("Error in collector")
        println(value)
    }
}

A IllegalStateException: Oops

B NullPointerException

C No error, prints 1

D ArithmeticException: Error in collector

💡 Hint

Exceptions thrown inside collect are not caught by catch in the flow.

The flow emits 1, then the collector throws an ArithmeticException when processing 1. This exception is not caught by the flow's catch, so it propagates.

🧠 Conceptual

advanced

Which operator handles exceptions inside the flow builder?

In Kotlin Flow, which operator is designed to catch exceptions thrown inside the flow builder block?

A <code>catch</code>

B <code>onCompletion</code>

C <code>retry</code>

D <code>collect</code>

💡 Hint

Think about which operator intercepts exceptions during emission.

The catch operator intercepts exceptions thrown inside the flow builder and allows handling or emitting fallback values.

❓ Predict Output

advanced

What is the output of this Kotlin Flow with retry?

What will this Kotlin program print?

Kotlin

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

var attempt = 0

fun main() = runBlocking {
    flow {
        attempt++
        if (attempt < 3) throw Exception("Try again")
        emit("Success on attempt $attempt")
    }
    .retry(2)
    .catch { e -> emit("Failed after retries") }
    .collect { println(it) }
}

A Success on attempt 3

B Failed after retries

C Exception in thread "main" java.lang.Exception: Try again

D Success on attempt 1

💡 Hint

The retry operator retries the flow emission on exceptions.

The flow throws exceptions on attempts 1 and 2, then succeeds on attempt 3. The retry(2) allows two retries, so it succeeds and emits "Success on attempt 3".

🔧 Debug

expert

Why does this Kotlin Flow catch block not catch the exception?

Examine this Kotlin code. Why does the catch block not catch the exception?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        emit(2)
    }
    .catch { e -> println("Caught: $e") }
    .collect { value ->
        if (value == 2) throw RuntimeException("Error in collector")
        println(value)
    }
}

A Because the flow does not throw any exception

B Because the catch operator must be before collect to catch exceptions

C Because exceptions in the collector are not caught by the flow's catch operator

D Because RuntimeException is not caught by catch

💡 Hint

Consider where exceptions are thrown and where catch applies.

The catch operator only catches exceptions thrown upstream in the flow builder or operators before collect. Exceptions thrown inside collect are outside its scope and propagate normally.

Practice

1. What is the primary purpose of the catch operator in Kotlin Flow?

easy

A. To start collecting the flow

B. To handle exceptions that occur during the flow emission

C. To transform emitted values into another type

D. To cancel the flow collection

Solution

1. Step 1: Understand the role of catch in Flow

   The catch operator is designed to intercept exceptions that happen during the emission of values in a Flow.

2. Step 2: Differentiate from other operators

   Operators like map transform values, collect starts the flow, and cancel stops it. Only catch handles errors.

3. Final Answer:

   To handle exceptions that occur during the flow emission -> Option B

4. Quick Check:

   Flow error handling = catch [OK]

Hint: Remember: catch is for errors inside Flow [OK]

Common Mistakes:

• Confusing catch with map or collect
• Thinking catch cancels the flow
• Assuming catch transforms values

2. Which of the following is the correct syntax to catch exceptions in a Kotlin Flow?

easy

A. flow.catch { e -> emit(fallbackValue) }

B. flow.try { e -> emit(fallbackValue) }

C. flow.handle { e -> emit(fallbackValue) }

D. flow.error { e -> emit(fallbackValue) }

Solution

1. Step 1: Recall the correct operator name

   The operator to handle exceptions in Kotlin Flow is catch, not try, handle, or error.

2. Step 2: Verify the lambda syntax

   The lambda receives the exception e and can emit fallback values inside it, matching the syntax flow.catch { e -> emit(fallbackValue) }.

3. Final Answer:

   flow.catch { e -> emit(fallbackValue) } -> Option A

4. Quick Check:

   Correct catch syntax = flow.catch { e -> ... } [OK]

Hint: Use catch, not try, for Flow exceptions [OK]

Common Mistakes:

• Using try instead of catch
• Wrong operator names like handle or error
• Incorrect lambda parameter usage

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

import kotlinx.coroutines.flow.*
suspend fun main() {
    flow {
        emit(1)
        throw RuntimeException("Error!")
    }
    .catch { emit(99) }
    .collect { println(it) }
}

medium

A. 1
Error!

B. Only 99

C. Error! Exception thrown

D. 1
99

Solution

1. Step 1: Analyze the flow emissions and exception

   The flow emits 1, then throws a RuntimeException. The catch operator catches this exception and emits 99 as a fallback.

2. Step 2: Understand the collection output

   The collector prints each emitted value. So it prints 1 first, then after catching the exception, it prints 99.

3. Final Answer:

   1 99 -> Option D

4. Quick Check:

   Emit before error + catch fallback = 1 and 99 [OK]

Hint: catch emits fallback after error, original emits stay [OK]

Common Mistakes:

• Expecting exception message to print
• Thinking flow stops without catch
• Ignoring emitted values before error

4. Identify the error in this Kotlin Flow exception handling code:

flow {
    emit(10)
    throw IllegalStateException("Oops")
}.catch { e ->
    println("Caught: $e")
}.collect {
    println(it)
}

medium

A. Missing emit inside catch to provide fallback value

B. catch block should be after collect

C. collect should be inside catch block

D. No error, code is correct

Solution

1. Step 1: Review catch usage

   The catch block prints the exception but does not emit any fallback value, so the flow ends after the exception.

2. Step 2: Understand flow continuation

   Without emitting a fallback value inside catch, the collector won't receive any value after the error, which might not be intended.

3. Final Answer:

   Missing emit inside catch to provide fallback value -> Option A

4. Quick Check:

   catch without emit = no fallback value [OK]

Hint: Emit fallback inside catch to continue flow after error [OK]

Common Mistakes:

• Placing catch after collect
• Trying to collect inside catch
• Not emitting fallback value in catch

5. You want to create a Kotlin Flow that emits numbers 1 to 3, but if an exception occurs, it should emit -1 and then complete. Which code snippet correctly implements this behavior?

hard

A. flow {
for (i in 1..3) emit(i)
}.catch { emit(-1) }

B. flow {
for (i in 1..3) {
if (i == 4) throw Exception()
emit(i)
}
}.catch { emit(-1) }

C. flow {
for (i in 1..3) {
if (i == 2) throw Exception()
emit(i)
}
}.catch { emit(-1) }

D. flow {
for (i in 1..3) emit(i)
}.catch { throw Exception() }

Solution

1. Step 1: Identify where exception occurs

   flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } throws an exception at i == 2, triggering the catch block to emit -1 as fallback.

2. Step 2: Confirm fallback emission and completion

   The catch block emits -1, then the flow completes. Codes without throwing an exception during the emission loop do not trigger catch. Code that rethrows the exception in catch does not emit fallback.

3. Final Answer:

   flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } -> Option C

4. Quick Check:

   Throw inside flow + catch emit fallback = flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } [OK]

Hint: Throw inside flow, catch emits fallback -1 [OK]

Common Mistakes:

• Not throwing exception inside emission loop
• Rethrowing exception in catch instead of emitting fallback
• Throwing exception outside emission range