Result type for functional error handling in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using Result?

Consider this Kotlin code that uses Result to handle errors functionally. What will it print?

Kotlin

fun divide(a: Int, b: Int): Result<Int> =
    if (b == 0) Result.failure(ArithmeticException("Division by zero"))
    else Result.success(a / b)

fun main() {
    val result = divide(10, 0)
    println(result.getOrElse { _ -> -1 })
}

A Exception in thread "main" java.lang.ArithmeticException: Division by zero

B 0

C -1

D 10

💡 Hint

Look at how getOrElse works when the Result is a failure.

The divide function returns a failure Result when dividing by zero. The getOrElse method returns the success value or the default value if failure. Here, it returns -1 because division by zero fails.

❓ Predict Output

intermediate

What does this Kotlin code print when using Result.fold?

Given this Kotlin code using Result.fold, what will be printed?

Kotlin

fun parseNumber(str: String): Result<Int> =
    try {
        Result.success(str.toInt())
    } catch (e: NumberFormatException) {
        Result.failure(e)
    }

fun main() {
    val result = parseNumber("abc")
    val output = result.fold(
        onSuccess = { "Number: $it" },
        onFailure = { "Error: ${it.message}" }
    )
    println(output)
}

A Error: For input string: "abc"

B Number: abc

C Number: 0

D Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"

💡 Hint

Think about what happens when toInt() fails and how fold handles success and failure.

The parseNumber function returns a failure Result because "abc" is not a valid integer. The fold method calls onFailure lambda, printing the error message.

❓ Predict Output

advanced

What is the output of this Kotlin code chaining Result operations?

Analyze this Kotlin code that chains Result operations with map and recover. What will it print?

Kotlin

fun riskyOperation(x: Int): Result<Int> =
    if (x > 0) Result.success(100 / x) else Result.failure(IllegalArgumentException("x must be positive"))

fun main() {
    val result = riskyOperation(0)
        .map { it * 2 }
        .recover<IllegalArgumentException> { _ -> 42 }
    println(result.getOrNull())
}

A 200

B 0

C Exception in thread "main" java.lang.IllegalArgumentException: x must be positive

D 42

💡 Hint

Check what recover does when the Result is a failure.

The riskyOperation returns a failure because x is 0. The map is skipped. The recover replaces the failure with success value 42. So getOrNull() returns 42.

❓ Predict Output

advanced

What error does this Kotlin code raise when accessing Result's value?

What error will this Kotlin code produce when run?

Kotlin

fun main() {
    val failureResult: Result<Int> = Result.failure(RuntimeException("Failed operation"))
    println(failureResult.getOrThrow())
}

A IllegalStateException

B RuntimeException: Failed operation

C NoSuchElementException

D NullPointerException

💡 Hint

Look at what getOrThrow() does when the Result is a failure.

The getOrThrow() method throws the exception stored in the failure Result. Here it throws the RuntimeException with message "Failed operation".

🧠 Conceptual

expert

How many items are in the resulting list after this Kotlin Result sequence?

Consider this Kotlin code that collects successful results from a list of Result values. How many items will be in the successes list?

Kotlin

fun main() {
    val results = listOf(
        Result.success(1),
        Result.failure(Exception("fail 1")),
        Result.success(2),
        Result.failure(Exception("fail 2")),
        Result.success(3)
    )
    val successes = results.mapNotNull { it.getOrNull() }
    println(successes.size)
}

A 3

B 2

C 5

D 0

💡 Hint

Remember that getOrNull() returns the value if success, or null if failure.

There are 3 successful Result objects (1, 2, 3). The mapNotNull collects only these values, so the list size is 3.

Practice

1. What does the Kotlin Result type represent in functional error handling?

easy

A. A special type of exception thrown during errors

B. An object that holds either a success value or a failure exception

C. A function that always returns a Boolean

D. A list of all errors encountered during execution

Solution

1. Step 1: Understand the purpose of Result type

   The Result type is designed to wrap either a successful outcome or an error, making error handling explicit and functional.

2. Step 2: Identify what Result holds

   Result holds either a success value or a failure exception, not a list or a Boolean or an exception thrown directly.

3. Final Answer:

   An object that holds either a success value or a failure exception -> Option B

4. Quick Check:

   Result = success or failure [OK]

Hint: Result always wraps success or failure, not exceptions thrown [OK]

Common Mistakes:

• Thinking Result is an exception type
• Confusing Result with Boolean return
• Assuming Result holds multiple errors

2. Which of the following is the correct way to create a successful Result object in Kotlin?

easy

A. Result.makeSuccess(value)

B. Result.ofSuccess(value)

C. Result.createSuccess(value)

D. Result.success(value)

Solution

1. Step 1: Recall the Kotlin Result API

   Kotlin provides Result.success(value) to create a successful Result wrapping the value.

2. Step 2: Check method names

   Only Result.success is the correct and existing method; others are invalid.

3. Final Answer:

   Result.success(value) -> Option D

4. Quick Check:

   Use Result.success() to wrap success [OK]

Hint: Use Result.success() to wrap success values [OK]

Common Mistakes:

• Using non-existent methods like Result.ofSuccess
• Confusing with factory methods
• Trying to create Result with constructors

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

val result = runCatching { 10 / 0 }
result.onSuccess { println("Success: $it") }
result.onFailure { println("Failure: ${it.message}") }

medium

A. Failure: / by zero

B. Success: 0

C. No output

D. RuntimeException thrown

Solution

1. Step 1: Understand runCatching behavior

   runCatching executes the block and catches exceptions, wrapping them in Result.failure.

2. Step 2: Analyze division by zero

   10 / 0 throws an ArithmeticException with message "/ by zero" which is caught and triggers onFailure.

3. Final Answer:

   Failure: / by zero -> Option A

4. Quick Check:

   Exception caught triggers onFailure [OK]

Hint: runCatching catches exceptions and calls onFailure [OK]

Common Mistakes:

• Expecting program to crash with exception
• Thinking onSuccess runs despite error
• Ignoring exception message in output

4. Identify the error in this Kotlin code using Result for error handling:

fun divide(a: Int, b: Int): Result<Int> {
    return try {
        Result.success(a / b)
    } catch (e: Exception) {
        Result.failure(e)
    }
}

val result = divide(10, 0)
result.onSuccess { println("Result: $it") }
      .onFailure { println("Error: ${it.message}") }

medium

A. Cannot chain onSuccess and onFailure directly on Result

B. Should catch ArithmeticException instead of Exception

C. Result.failure should not be used inside catch block

D. No error, code works correctly

Solution

1. Step 1: Check chaining onSuccess and onFailure

   In Kotlin, onSuccess and onFailure are extension functions returning Unit, so chaining them directly causes a compile error.

2. Step 2: Verify other parts

   Try-catch with Result.success and Result.failure is correct; catching Exception is acceptable; Result.failure is valid.

3. Final Answer:

   Cannot chain onSuccess and onFailure directly on Result -> Option A

4. Quick Check:

   onSuccess and onFailure return Unit, no chaining [OK]

Hint: onSuccess/onFailure return Unit, cannot chain calls [OK]

Common Mistakes:

• Trying to chain onSuccess and onFailure
• Thinking catch block must catch ArithmeticException only
• Misusing Result.failure inside catch

5. You want to write a Kotlin function that returns a Result wrapping the parsed integer from a string, or a failure if parsing fails. Which implementation correctly uses Result for this purpose?

hard

A. fun parseInt(str: String): Result<Int> = Result.failure(NumberFormatException())

B. fun parseInt(str: String): Result<Int> = Result.success(str.toIntOrNull() ?: throw NumberFormatException())

C. fun parseInt(str: String): Result<Int> = try { Result.success(str.toInt()) } catch (e: NumberFormatException) { Result.failure(e) }

D. fun parseInt(str: String): Int = str.toIntOrNull() ?: -1

Solution

1. Step 1: Understand the goal

   The function should return Result wrapping success if parsing works, or failure if it throws NumberFormatException.

2. Step 2: Analyze each option

   fun parseInt(str: String): Result<Int> = try { Result.success(str.toInt()) } catch (e: NumberFormatException) { Result.failure(e) } uses try-catch to wrap success or failure correctly. fun parseInt(str: String): Result<Int> = Result.success(str.toIntOrNull() ?: throw NumberFormatException()) throws exception outside Result.failure, breaking functional style. fun parseInt(str: String): Result<Int> = Result.failure(NumberFormatException()) always returns failure, ignoring input. fun parseInt(str: String): Int = str.toIntOrNull() ?: -1 returns Int, not Result.

3. Final Answer:

   fun parseInt(str: String): Result<Int> = try { Result.success(str.toInt()) } catch (e: NumberFormatException) { Result.failure(e) } -> Option C

4. Quick Check:

   Try-catch with Result.success/failure wraps parsing safely [OK]

Hint: Use try-catch with Result.success and Result.failure for safe parsing [OK]

Common Mistakes:

• Throwing exceptions instead of wrapping in Result.failure
• Returning plain Int instead of Result<Int>
• Always returning failure ignoring input