Flow exception handling in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch exceptions in a Flow using the catch operator.

Kotlin

flowOf(1, 2, 3)
    .[1] { e -> emit(-1) }

Drag options to blanks, or click blank then click option'

Acatch

Bcollect

Cmap

Dfilter

Attempts:

3 left

💡 Hint

Common Mistakes

Using collect instead of catch to handle exceptions.

Using map or filter which do not handle exceptions.

The catch operator is used to handle exceptions in a Flow.

2fill in blank

medium

Complete the code to emit a fallback value when an exception occurs in the Flow.

Kotlin

flow {
    emit(1)
    throw RuntimeException("Error")
}.catch { [1] -> emit(0) }

Drag options to blanks, or click blank then click option'

Ae

Bexception

Cerror

Dex

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name that is not used in the lambda.

Forgetting to name the exception parameter.

The lambda parameter in catch is commonly named e to represent the exception.

3fill in blank

hard

Fix the error in the code to properly handle exceptions in the Flow.

Kotlin

flow {
    emit(1)
    throw Exception("Fail")
}.[1] { e -> emit(-1) }

Drag options to blanks, or click blank then click option'

AcatchError

BhandleException

ConError

Dcatch

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent operators like catchError or onError.

Trying to handle exceptions outside the Flow operators.

The correct operator to handle exceptions in a Flow is catch.

4fill in blank

hard

Fill both blanks to emit values and handle exceptions with catch.

Kotlin

flow {
    emit(10)
    emit(20)
    throw Exception("Oops")
}.[1] { e ->
    emit([2])
}

Drag options to blanks, or click blank then click option'

Acatch

Bcollect

C30

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using collect instead of catch for exception handling.

Emitting a value that does not indicate an error fallback.

Use catch to handle exceptions and emit a fallback value like -1.

5fill in blank

hard

Fill all three blanks to create a Flow that emits numbers, handles exceptions, and collects the results.

Kotlin

val flow = flow {
    emit(1)
    emit(2)
    throw Exception("Error")
}

flow.[1] { e ->
    emit([2])
}.[3] { value ->
    println(value)
}

Drag options to blanks, or click blank then click option'

Acatch

B0

Ccollect

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using map instead of catch for exception handling.

Forgetting to collect the Flow to trigger execution.

Emitting a wrong fallback value.

Use catch to handle exceptions, emit a fallback value 0, and then collect to process the emitted values.

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