runCatching and Result<T>
Use runCatching to wrap exceptions in Result and process them functionally.
runCatching and Result<T> is a free Kotlin Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Result<T> in a Nutshell
Result<T> is Kotlin's wrapper for an operation outcome: either a success with a value of type T or a failure with a Throwable.
runCatching Basics
runCatching { ... } runs the block and wraps the outcome in a Result.
fun main() {
val good = runCatching { 10 / 2 }
val bad = runCatching { 10 / 0 }
println("good isSuccess = ${good.isSuccess}")
println("bad isFailure = ${bad.isFailure}")
}Extracting the Value
getOrNull returns the value or null. getOrThrow rethrows on failure. getOrDefault returns a fallback.
fun main() {
val r = runCatching { "42".toInt() }
println(r.getOrNull()) // 42
println(r.getOrDefault(-1)) // 42
val bad = runCatching { "x".toInt() }
println(bad.getOrNull()) // null
println(bad.getOrDefault(0)) // 0
}Extracting the Exception
exceptionOrNull() returns the exception on failure, or null on success.
fun main() {
val r = runCatching { error("boom") }
println(r.exceptionOrNull()?.message) // boom
}Transforming with map
map { value -> ... } transforms the success value. Failure passes through untouched.
fun main() {
val r = runCatching { "10" }.map { it.toInt() * 2 }
println(r.getOrNull()) // 20
}mapCatching
mapCatching wraps the transformation in a try/catch so exceptions inside the lambda also become failures.
fun main() {
val r = runCatching { "abc" }.mapCatching { it.toInt() }
println(r.isFailure) // true
println(r.exceptionOrNull()?.message) // For input string: "abc"
}recover and recoverCatching
recover { e -> fallback } turns failures into successes by computing a recovery value.
fun main() {
val r = runCatching { "abc".toInt() }
.recover { -1 }
println(r.getOrNull()) // -1
}onSuccess / onFailure
Use onSuccess and onFailure for side effects without changing the Result.
fun main() {
runCatching { "42".toInt() }
.onSuccess { println("parsed: $it") }
.onFailure { println("failed: ${it.message}") }
}fold for Both Paths
fold(onSuccess, onFailure) returns a unified type from either branch — useful for converting to a UI-ready value.
fun main() {
val r = runCatching { "10".toInt() }
val msg: String = r.fold(
onSuccess = { "OK: $it" },
onFailure = { "ERR: ${it.message}" }
)
println(msg)
}Using Result as Return Type
Functions can return Result<T> to make error handling explicit at the call site.
fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
parseInt("42").onSuccess { println("got $it") }
parseInt("xx").onFailure { println("oops: ${it.message}") }
}Chaining Operations
Combine runCatching with map, mapCatching, recover for fluent error pipelines.
fun fetchUserId(): Result<Int> = runCatching { 42 }
fun loadName(id: Int): String = "User-$id"
fun main() {
val name = fetchUserId()
.map { loadName(it) }
.recover { "Anonymous" }
.getOrNull()
println(name)
}Quick Check
Which builder runs a block and wraps the outcome (value or exception) in a Result?
Recap
Result<T> represents success-or-failure. Create with runCatching; transform with map/mapCatching; recover with recover; observe with onSuccess/onFailure; collapse with fold. Great for explicit error pipelines.
Frequently asked questions
Is the “runCatching and Result<T>” lesson free?
Yes — the full text of “runCatching and Result<T>” is free to read here on the web, and the Kotlin Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Kotlin Academy course, upgrade to CoddyKit PRO.
What will I learn in “runCatching and Result<T>”?
Use runCatching to wrap exceptions in Result and process them functionally. You practise Kotlin Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Kotlin Academy?
No prior experience is required. Kotlin Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “runCatching and Result<T>” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Kotlin Academy lesson?
Yes. Every Kotlin Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.