RunCatching for safe execution in Kotlin - Step-by-Step Execution

Concept Flow - RunCatching for safe execution

Start

↓

RunCatching block

↓

Try to execute code

↓

Success?

Yes→Return Success Result

↓

Catch Exception

↓

Return Failure Result

↓

Use Result safely

↓

End

RunCatching tries to run code safely, catching exceptions and returning a Result object that shows success or failure.

Execution Sample

Kotlin

val result = runCatching {
    val x = 10 / y
    "Result is $x"
}
println(result.getOrElse { "Error: ${it.message}" })

This code tries to divide 10 by y safely, catching any error and printing the result or error message.

Execution Table

Step	Action	Evaluation	Result
1	Enter runCatching block	Start code inside runCatching	No result yet
2	Evaluate 10 / y	If y=2, 10/2=5	5
3	Create string "Result is 5"	String formed	"Result is 5"
4	runCatching returns Success("Result is 5")	Success result	Success("Result is 5")
5	Call getOrElse on Success	Returns success value	"Result is 5"
6	Print output	Output to console	Result is 5
7	If y=0, division throws exception	Exception caught	Failure(ArithmeticException)
8	Call getOrElse on Failure	Returns fallback string	"Error: / by zero"
9	Print output	Output to console	Error: / by zero

💡 Execution stops after printing the result or error message.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
y	2 or 0	2 or 0	2 or 0	2 or 0	2 or 0
x	undefined	5 or exception	5 or exception	5 or exception	5 or exception
result	undefined	undefined	undefined	Success or Failure	Success or Failure

Key Moments - 3 Insights

Why does runCatching not crash the program when division by zero happens?

Because runCatching catches the exception inside its block and returns a Failure result instead of letting the exception crash the program (see steps 7 and 8 in execution_table).

What does getOrElse do with the Result object?

getOrElse returns the success value if present, or the fallback value if the Result is a failure (see steps 5 and 8 in execution_table).

Is the code inside runCatching executed immediately or deferred?

It is executed immediately when runCatching is called, but safely inside a try-catch block (see step 2 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 4 when y=2?

A Success("Result is 5")

B Failure(ArithmeticException)

C "Result is 5"

D Exception thrown

💡 Hint

Check the 'Result' column at step 4 in execution_table.

At which step does runCatching catch an exception if y=0?

A Step 2

B Step 7

C Step 5

D Step 9

💡 Hint

Look for the step mentioning exception caught in execution_table.

If we change getOrElse fallback to "Oops", what will be printed when y=0?

A "Result is 5"

B "Error: / by zero"

C "Oops"

D Program crashes

💡 Hint

Check step 8 and 9 in execution_table where getOrElse fallback is used.

Concept Snapshot

runCatching { code } runs code safely.
Returns Result: Success(value) or Failure(exception).
Use getOrElse { fallback } to get value or fallback.
Prevents crashes from exceptions inside block.
Ideal for safe error handling.

Full Transcript

RunCatching in Kotlin lets you run code that might fail without crashing your program. It tries to run the code inside its block. If the code works, it returns a Success result with the value. If the code throws an exception, runCatching catches it and returns a Failure result with the exception. You can then use getOrElse on the Result to get the success value or provide a fallback value if there was an error. This way, your program stays safe and you handle errors gracefully.

Practice

1. What is the main purpose of runCatching in Kotlin?

easy

A. To execute code and catch exceptions safely without crashing the program

B. To run code only if a condition is true

C. To create a new thread for running code

D. To convert a value to a string safely

Solution

1. Step 1: Understand what runCatching does

   runCatching runs a block of code and catches any exceptions that happen inside it.

2. Step 2: Identify the main purpose

   This helps keep the program running smoothly by handling errors safely without crashing.

3. Final Answer:

   To execute code and catch exceptions safely without crashing the program -> Option A

4. Quick Check:

   runCatching = safe execution [OK]

Hint: runCatching catches errors to keep code safe [OK]

Common Mistakes:

• Thinking runCatching runs code conditionally
• Confusing runCatching with threading
• Assuming it converts types automatically

2. Which of the following is the correct syntax to use runCatching in Kotlin?

easy

A. val result = runCatching -> someFunction()

B. val result = runCatching(someFunction())

C. val result = runCatching { someFunction() }

D. val result = runCatching.someFunction()

Solution

1. Step 1: Recall the syntax of runCatching

   runCatching takes a lambda block with curly braces to run code safely.

2. Step 2: Match the correct syntax

   val result = runCatching { someFunction() } uses curly braces and calls someFunction() inside, which is correct.

3. Final Answer:

   val result = runCatching { someFunction() } -> Option C

4. Quick Check:

   runCatching uses braces { } [OK]

Hint: Use curly braces {} to pass code block to runCatching [OK]

Common Mistakes:

• Using parentheses instead of braces
• Trying to call runCatching like a function with arrow
• Accessing runCatching as an object

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

val result = runCatching { 10 / 0 }
println(result.isSuccess)

medium

A. true

B. null

C. Exception thrown

D. false

Solution

1. Step 1: Analyze the code inside runCatching

   The code tries to divide 10 by 0, which causes an exception (ArithmeticException).

2. Step 2: Understand runCatching result

   runCatching catches the exception, so no crash happens. The isSuccess property will be false because the block failed.

3. Final Answer:

   false -> Option D

4. Quick Check:

   Exception caught means isSuccess = false [OK]

Hint: Divide by zero causes failure, so isSuccess is false [OK]

Common Mistakes:

• Expecting true because code runs
• Thinking exception is thrown outside runCatching
• Confusing isSuccess with isFailure

4. Identify the error in this Kotlin code using runCatching:

val result = runCatching {
    val number = "abc".toInt()
}
println(result.getOrNull())

medium

A. No error, prints null because conversion fails

B. Throws NumberFormatException outside runCatching

C. Syntax error in runCatching block

D. getOrNull() returns the string "abc"

Solution

1. Step 1: Understand the code inside runCatching

   Trying to convert "abc" to Int causes NumberFormatException, but runCatching catches it.

2. Step 2: Check what getOrNull() returns

   Since exception happened, getOrNull() returns null safely without crashing.

3. Final Answer:

   No error, prints null because conversion fails -> Option A

4. Quick Check:

   Exception caught means getOrNull() = null [OK]

Hint: runCatching catches exceptions, getOrNull returns null on failure [OK]

Common Mistakes:

• Expecting exception to crash program
• Thinking getOrNull returns original string
• Assuming syntax error in code block

5. You want to safely parse a list of strings to integers using runCatching and collect only the successful results. Which Kotlin code snippet correctly does this?

hard

A. val numbers = list.map { runCatching { it.toInt() }.exceptionOrNull() }

B. val numbers = list.map { runCatching { it.toInt() }.getOrNull() }.filterNotNull()

C. val numbers = list.map { it.toInt() }.filter { it != null }

D. val numbers = list.map { runCatching { it.toInt() }.getOrThrow() }

Solution

1. Step 1: Understand the goal

   We want to convert strings to integers safely, ignoring failures, and collect only successful integers.

2. Step 2: Analyze each option

   val numbers = list.map { runCatching { it.toInt() }.getOrNull() }.filterNotNull() uses runCatching to catch exceptions, then getOrNull() returns integer or null, and filterNotNull() removes nulls, collecting only successful parses.

3. Final Answer:

   val numbers = list.map { runCatching { it.toInt() }.getOrNull() }.filterNotNull() -> Option B

4. Quick Check:

   Safe parse + filter null = val numbers = list.map { runCatching { it.toInt() }.getOrNull() }.filterNotNull() [OK]

Hint: Use getOrNull() then filterNotNull() to keep successful parses [OK]

Common Mistakes:

• Using getOrThrow() which throws on failure
• Filtering nulls before catching exceptions
• Using exceptionOrNull() which returns exceptions, not values