Kotlin Academy · Aula

Tratamento Funcional de Erros

Mapeie e recupere

Tratamento Funcional de Erros é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Erros como Fluxos de Dados

O tratamento funcional de erros considera as falhas como valores dos quais você pode transformar, encadear e recuperar — assim como transforma valores de success. O Result integrado oferece operadores exatamente para isso.

Mapeamento

map transforma um valor de success e deixa uma failure intacta, propagando-a sem alterações.

fun main() {
    val r = Result.success(5).map { it * 2 }
    println(r.getOrNull())
    val f = Result.failure<Int>(Exception("x")).map { it * 2 }
    println(f.getOrNull())
}

mapCatching

Se a própria transformação puder lançar uma exceção, mapCatching captura essa exceção no resultado em vez de permitir que ela escape.

fun main() {
    val r = Result.success("10").mapCatching { it.toInt() }
    println(r.getOrNull())
    val bad = Result.success("oops").mapCatching { it.toInt() }
    println(bad.isFailure)
}

Recuperação

recover transforma uma failure novamente em success, calculando um valor a partir da exceção. Um success passa sem alterações.

fun main() {
    val r = Result.failure<Int>(Exception("down")).recover { 0 }
    println(r.getOrNull())
    val ok = Result.success(7).recover { 0 }
    println(ok.getOrNull())
}

recoverCatching

Quando a lógica de recuperação também pode falhar, recoverCatching encapsula essa tentativa, mantendo tudo como um resultado.

fun main() {
    val r = Result.failure<Int>(Exception()).recoverCatching {
        "5".toInt()
    }
    println(r.getOrNull())
}

onSuccess e onFailure

Essas funções executam efeitos colaterais sem alterar o resultado e o devolvem para continuar o encadeamento. São ótimas para registrar informações.

fun main() {
    runCatching { "3".toInt() }
        .onSuccess { println("ok " + it) }
        .onFailure { println("fail " + it.message) }
        .also { println("done") }
}

Encadeando um fluxo

Os operadores se combinam em um fluxo claro: captura, transformação e recuperação, tudo sem blocos try/catch aninhados.

fun main() {
    val result = runCatching { "21".toInt() }
        .map { it * 2 }
        .recover { -1 }
        .getOrThrow()
    println(result)
}

fold para um valor final

Encerre um fluxo com fold para transformar os dois ramos em um único valor concreto, como uma mensagem para o usuário.

fun main() {
    val msg = runCatching { "x".toInt() }
        .map { it + 1 }
        .fold(
            onSuccess = { "result: " + it },
            onFailure = { "failed: " + it.message }
        )
    println(msg)
}

Mapeando um tipo personalizado

Você pode oferecer ao seu próprio tipo de resultado selado a mesma praticidade escrevendo funções de extensão, como map.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    data class Err(val msg: String) : Res<Nothing>()
}

fun <T, R> Res<T>.map(f: (T) -> R): Res<R> = when (this) {
    is Res.Ok -> Res.Ok(f(v))
    is Res.Err -> this
}

fun main() {
    val r = Res.Ok(4).map { it * 3 }
    println(r)
}

Por que usar o estilo funcional

O tratamento funcional de erros mantém o fluxo de sucesso legível, enquanto os erros fluem de forma declarativa. Não há blocos try/catch espalhados, e o sistema de tipos acompanha a falha de ponta a ponta.

Reunindo tudo

Agora você tem um conjunto completo de ferramentas:

map / mapCatching para transformar
recover / recoverCatching para recuperar
onSuccess / onFailure para efeitos colaterais
fold para finalizar

Verificação rápida

Teste sua compreensão sobre o tratamento funcional de erros.

Recapitulação

Você aprendeu o tratamento funcional de erros:

Transformar com map / mapCatching
Recuperar com recover / recoverCatching
Observar com onSuccess / onFailure
Finalizar com fold

Isso conclui o curso sobre resultados e modelagem de erros.

Perguntas Frequentes

A aula “Tratamento Funcional de Erros” é grátis?

Sim — o texto completo de “Tratamento Funcional de Erros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento Funcional de Erros”?

Mapeie e recupere Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tratamento Funcional de Erros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy