Kotlin Academy · Aula

Hierarquias Result Seladas

Tipos de resultado personalizados

Aula 3 de 413 etapas

Hierarquias Result Seladas é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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.

Além do Result Integrado

O Result do Kotlin carrega apenas uma exceção em caso de failure. Muitas vezes, você deseja informações de erro mais ricas e tipadas. Uma hierarquia de classe selada permite modelar exatamente os resultados possíveis do seu domínio.

Um Outcome Selado

Defina um tipo selado com subclasses de success e erro. O compilador conhece todos os casos, permitindo um tratamento exaustivo.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun main() {
    val r: Outcome<Int> = Outcome.Ok(5)
    println(r)
}

when Exaustivo

Como o tipo é selado, um when sobre ele não precisa de else, e o compilador exige o tratamento de todos os casos.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun describe(o: Outcome<Int>) = when (o) {
    is Outcome.Ok -> "value " + o.value
    is Outcome.Err -> "error " + o.message
}

fun main() {
    println(describe(Outcome.Ok(9)))
    println(describe(Outcome.Err("boom")))
}

Variantes de Erro Tipadas

Modele tipos distintos de failure como subclasses separadas, cada uma contendo os dados relevantes. Isso é melhor do que uma única exceção opaca.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun main() {
    val r: Fetch<String> = Fetch.NotFound(42)
    println(r)
}

Tratando Cada Variante

Um when pode reagir especificamente a cada tipo de erro, com todos os dados disponíveis em cada ramo.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun handle(f: Fetch<String>) = when (f) {
    is Fetch.Success -> "data: " + f.data
    is Fetch.NotFound -> "missing id " + f.id
    is Fetch.Network -> "net error " + f.code
}

fun main() {
    println(handle(Fetch.Network(503)))
}

O Truque do Nothing

Variantes de erro que não contêm um valor de success usam Outcome<Nothing>. Como Nothing é um subtipo de todos os tipos e o tipo genérico é out, um erro se encaixa em qualquer Outcome<T>.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    object Empty : Res<Nothing>()
}

fun get(flag: Boolean): Res<String> =
    if (flag) Res.Ok("hi") else Res.Empty

fun main() {
    println(get(false))
}

Objeto para Casos sem Estado

Se uma variante de erro não contiver dados, declare-a como um singleton object em vez de uma classe.

sealed class Login {
    data class Success(val user: String) : Login()
    object WrongPassword : Login()
    object Locked : Login()
}

fun main() {
    val r: Login = Login.WrongPassword
    println(r === Login.WrongPassword)
}

Retornando a Hierarquia

As funções retornam o tipo selado; os chamadores precisam tratar todos os resultados, eliminando caminhos de erro esquecidos.

sealed class Parsed {
    data class Num(val value: Int) : Parsed()
    data class Bad(val input: String) : Parsed()
}

fun parse(s: String): Parsed {
    val n = s.toIntOrNull()
    return if (n != null) Parsed.Num(n) else Parsed.Bad(s)
}

fun main() {
    when (val r = parse("x")) {
        is Parsed.Num -> println(r.value)
        is Parsed.Bad -> println("bad: " + r.input)
    }
}

Result Selado em Comparação com o Result Integrado

Use o Result integrado para uma captura rápida baseada em exceções. Use uma hierarquia selada personalizada quando precisar de vários casos de erro tipados, com dados específicos do domínio e tratamento exaustivo.

Projetando a Hierarquia

Um bom projeto de resultado selado:

Uma variante de success contendo a carga útil
Uma subclasse para cada modo de failure significativo
Variância out T com Nothing para casos que contêm apenas erros

O Compilador como Rede de Segurança

A maior vantagem: quando você adiciona uma nova variante posteriormente, todo when não exaustivo se torna um erro de compilação, indicando cada local que precisa tratá-la. Os erros não podem passar despercebidos.

Verificação Rápida

Verifique sua compreensão sobre hierarquias seladas de resultados.

Responda na aula interativa

Recapitulação

Você criou hierarquias seladas de resultados:

Success e variantes de erro tipadas
when exaustivo sem else
out T e Nothing para casos que contêm apenas erros
Tratamento de novas variantes exigido pelo compilador

A seguir: tratamento funcional de erros com map e recover.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Hierarquias Result Seladas” é grátis?

Sim — o texto completo de “Hierarquias Result Seladas” é 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 “Hierarquias Result Seladas”?

Tipos de resultado personalizados 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 3 de 4.

Quanto tempo leva a aula “Hierarquias Result Seladas”?

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