0Pricing
Kotlin Academy · Aula

Option e Nullable: quando usar cada um

Compare o tipo Option do Arrow com os tipos anuláveis do Kotlin e escolha adequadamente.

Option e Nullable: quando usar cada um é 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.

Duas formas de representar a ausência

O Kotlin tem tipos anuláveis integrados (T?) que representam "um valor ou nada". O Arrow também fornece Option — um tipo selado com Some(value: A) e None. Ambos resolvem o mesmo problema, mas se encaixam em contextos diferentes.

Tipos anuláveis do Kotlin

O T? do Kotlin é a escolha idiomática para representar ausência na maior parte do código Kotlin. O compilador impõe verificações de nulo, o operador de chamada segura ?. encadeia chamadas com facilidade, e ?: "default" fornece valores alternativos de forma concisa:

val name: String? = findUser(id)?.name
val display = name ?: "Anonymous"

Option<A> do Arrow

Option encapsula o conceito de anulabilidade em um tipo algébrico apropriado, com map, flatMap, filter, fold e muito mais. Ele se integra naturalmente ao estilo de fluxo funcional do Arrow:

import arrow.core.Option
import arrow.core.Some
import arrow.core.None
import arrow.core.toOption

val opt: Option<String> = "hello".toOption()   // Some("hello")
val absent: Option<String> = None

Convertendo entre Option e tipos anuláveis

Faça a conversão livremente: value?.toOption() encapsula um valor anulável em Option; option.getOrNull() extrai o valor ou nulo; option.getOrElse { default } fornece um valor alternativo:

val opt: Option<String> = nullableString.toOption()
val back: String? = opt.getOrNull()

map e flatMap em Option

map { } transforma um valor Some (deixa None inalterado). flatMap { } encadeia operações que também retornam Option:

val length: Option<Int> = "hello".toOption().map { it.length }  // Some(5)
val noneLength: Option<Int> = (null as String?).toOption().map { it.length }  // None

filter em Option

filter { predicate } converte um Some em None se o predicado for falso:

val positiveAge: Option<Int> = 25.toOption().filter { it > 0 }  // Some(25)
val rejectedAge:  Option<Int> = (-1).toOption().filter { it > 0 }  // None

fold: consumindo Option

fold(ifEmpty, ifSome) trata ambos os casos em uma única expressão, sem correspondência de padrões:

val result: String = someOption.fold(
    ifEmpty = { "Nothing here" },
    ifSome  = { value -> "Got: $value" }
)

Quando preferir o tipo anulável T?

Prefira o tipo anulável do Kotlin (T?) quando:

Quando preferir Option<A>

Prefira Option quando:

Option dentro de either { }

Dentro do bloco either { } do Arrow, você pode chamar .bind() em um Option, convertendo-o primeiro em Either:

fun findUserOpt(id: Long): Option<User> = TODO()

fun getUser(id: Long): Either<UserError, User> = either {
    findUserOpt(id)
        .toEither { UserError.NotFound }
        .bind()
}

O antipadrão de opção

Não use Option em todo lugar apenas porque ele existe. No Kotlin, String? é mais claro do que Option na maior parte do código de aplicações. Reserve Option para situações em que seus operadores funcionais realmente agreguem valor.

Verificação rápida

O que None.map { it.length } retorna em Option do Arrow?

Recapitulação: opção e valores anuláveis

Principais aprendizados:

Perguntas Frequentes

A aula “Option e Nullable: quando usar cada um” é grátis?

Sim — o texto completo de “Option e Nullable: quando usar cada um” é 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 “Option e Nullable: quando usar cada um”?

Compare o tipo Option do Arrow com os tipos anuláveis do Kotlin e escolha adequadamente. 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 “Option e Nullable: quando usar cada um”?

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

  1. Either : tratamento de erros tipado sem exceções
  2. DSL Raise do Arrow: composição de erros tipados
  3. Option e Nullable: quando usar cada um
  4. Modelagem funcional de domínios com os tipos centrais do Arrow
← Voltar para Kotlin Academy