Scala for Backend Engineering & Functional Programming · Aula

Either para erros

Left e Right.

Either para erros é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Por que usar Either?

Either representa um valor que pode ser uma de duas possibilidades. É a forma idiomática de modelar cálculos que podem falhar com informações sobre a falha.

Left normalmente contém o erro.
Right normalmente contém o valor de sucesso.

Diferentemente de Option, que apenas informa que algo está ausente, Either informa o que deu errado.

O tipo Either

Either[A, B] é um traço selado com dois subtipos: Left[A] e Right[B].

O mnemônico é: Right está certo (correto); Left representa o erro. Essa convenção permite que map e flatMap operem automaticamente no lado do sucesso.

val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)

Retornando Either de uma função

Uma função que pode falhar retorna um Either em vez de lançar uma exceção. Assim, quem a chama pode tratar explicitamente os dois resultados.

object Main {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 => Right(n)
      case Some(_)          => Left("age cannot be negative")
      case None             => Left("not a number")
    }

  def main(args: Array[String]): Unit = {
    println(parseAge("30"))
    println(parseAge("-5"))
    println(parseAge("x"))
  }
}

Correspondência de padrões com Either

A forma mais direta de consumir um Either é usar correspondência de padrões. Você trata Left e Right separadamente.

@main def run(): Unit = {
  val result: Either[String, Int] = Right(10)
  val msg = result match {
    case Right(value) => s"Got value: $value"
    case Left(error)  => s"Failed: $error"
  }
  println(msg)
}

fold: Unificando os dois lados

fold recebe duas funções: uma para Left e outra para Right, e produz um único resultado de um tipo comum.

É uma alternativa concisa à correspondência de padrões quando você quer obter um valor.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(7)
  val label = r.fold(
    err => s"error: $err",
    num => s"double is ${num * 2}"
  )
  println(label)
}

map funciona com Right

map transforma o valor de Right e deixa Left inalterado. Esse é o comportamento orientado à direita de Either no Scala (desde a versão 2.12).

@main def run(): Unit = {
  val ok: Either[String, Int]  = Right(5)
  val no: Either[String, Int]  = Left("missing")
  println(ok.map(_ + 1))
  println(no.map(_ + 1))
}

getOrElse e valores padrão

getOrElse extrai o valor de Right ou retorna um valor alternativo quando o Either é um Left.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(99)
  val no: Either[String, Int] = Left("oops")
  println(ok.getOrElse(0))
  println(no.getOrElse(0))
}

swap: Invertendo os lados

swap troca Left e Right. Isso é útil quando você quer operar no lado do erro usando métodos orientados à direita.

@main def run(): Unit = {
  val err: Either[String, Int] = Left("bad input")
  val swapped = err.swap.map(_.toUpperCase)
  println(swapped)
}

isLeft e isRight

Verificações booleanas rápidas permitem ramificar sem usar uma correspondência de padrões completa.

isRight retorna verdadeiro para um sucesso.
isLeft retorna verdadeiro para um erro.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: Descartando o erro

Quando você já não se importa por que algo falhou, toOption converte um Either em um Option: Right(x) se torna Some(x) e Left(_) se torna None.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(3)
  val no: Either[String, Int] = Left("err")
  println(ok.toOption)
  println(no.toOption)
}

Um exemplo de validação

Reunindo tudo: valide um nome de usuário, retornando um erro tipado em caso de falha.

object Main {
  def validate(name: String): Either[String, String] =
    if (name.isEmpty) Left("empty name")
    else if (name.length > 10) Left("name too long")
    else Right(name)

  def main(args: Array[String]): Unit = {
    println(validate("alice"))
    println(validate(""))
    println(validate("verylongusername"))
  }
}

Verificação rápida

Teste sua compreensão das convenções de Either.

Recapitulação

Você aprendeu a modelar erros com Either:

Right = sucesso, Left = erro (orientado à direita).
Consuma com correspondência de padrões ou fold.
Transforme o sucesso com map; forneça valores padrão com getOrElse.
Inverta os lados com swap; converta com toOption.

A seguir, você tratará exceções com Try.

Perguntas Frequentes

A aula “Either para erros” é grátis?

Sim — o texto completo de “Either para 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Either para erros”?

Left e Right. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 1 de 4.

Quanto tempo leva a aula “Either para 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 Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming