Flow exception handling in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of exception handling in Kotlin Flow?

Exception handling in Kotlin Flow is used to catch and manage errors that occur during the flow's emission or collection, preventing crashes and allowing graceful recovery.

beginner

Which operator is commonly used to catch exceptions in a Kotlin Flow?

The catch operator is used to catch exceptions emitted by the upstream flow and handle them, such as logging or emitting fallback values.

intermediate

How does the catch operator work in Kotlin Flow?

The catch operator intercepts exceptions from upstream flows. Inside its block, you can handle the exception or emit alternative values to continue the flow.

beginner

What happens if an exception is not caught in a Kotlin Flow?

If an exception is not caught, it will cancel the flow collection and propagate the error to the caller, potentially crashing the app or stopping the flow.

intermediate

Show a simple Kotlin Flow example that emits numbers and handles exceptions using catch.

```kotlin
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun simpleFlow(): Flow<Int> = flow {
    emit(1)
    emit(2)
    throw RuntimeException("Oops!")
}

fun main() = runBlocking {
    simpleFlow()
        .catch { e -> emit(-1) } // Emit -1 on error
        .collect { value -> println(value) }
}
```
This prints: 1, 2, -1

Which operator in Kotlin Flow is used to handle exceptions?

A catch

B map

C filter

D collect

The catch operator is specifically designed to catch exceptions in a flow.

What happens if an exception occurs in a flow and is not caught?

A The exception is ignored

B The flow continues normally

C The flow is cancelled and the exception propagates

D The flow retries automatically

Uncaught exceptions cancel the flow and propagate the error to the caller.

In the catch operator, what can you do with the caught exception?

A Only log it

B Ignore it silently

C Convert it to a different exception automatically

D Emit alternative values or rethrow

Inside catch, you can emit fallback values or rethrow the exception.

Where should the catch operator be placed in a flow chain to catch exceptions from upstream?

A After the operators that might throw exceptions

B Before any operators

C At the very end after <code>collect</code>

D It does not matter

catch should be placed after operators that might throw exceptions to catch them.

Which of these is NOT a valid way to handle exceptions in Kotlin Flow?

A Using <code>catch</code> operator

B Ignoring exceptions silently

C Using try-catch inside <code>flow</code> builder

D Using <code>retry</code> operator to retry on failure

Ignoring exceptions silently is not a good practice and not a valid handling method.

Explain how exception handling works in Kotlin Flow and why it is important.

Think about how errors can stop a flow and how catch helps.

Describe a simple example of using the catch operator in a Kotlin Flow to handle an error.

Imagine a flow that emits numbers but throws an error in the middle.

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