0Pricing
Scala for Backend Engineering & Functional Programming · Lezione

Either per gli errori

Left e Right

Either per gli errori è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Perché Either?

Either rappresenta un valore che può corrispondere a una di due possibilità. È il modo idiomatico per modellare calcoli che possono fallire fornendo informazioni sull'errore.

  • Left contiene convenzionalmente l'errore.
  • Right contiene convenzionalmente il valore del risultato positivo.

A differenza di Option, che indica solo che manca qualcosa, Either indica che cosa non ha funzionato.

Il tipo Either

Either[A, B] è un sealed trait con due sottotipi: Left[A] e Right[B].

Il promemoria è: Right is right (corretto), mentre Left rappresenta l'errore. Questa convenzione consente a map e flatMap di operare automaticamente sul lato del risultato positivo.

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

Restituire Either da una funzione

Una funzione che può fallire restituisce un Either invece di generare un'eccezione. Chi la chiama può quindi gestire esplicitamente entrambi gli esiti.

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"))
  }
}

Pattern matching su Either

Il modo più diretto di usare un Either è il pattern matching. Gestisca separatamente Left e Right.

@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: riunire entrambi i lati

fold accetta due funzioni, una per Left e una per Right, e produce un unico risultato di tipo comune.

È un'alternativa concisa al pattern matching quando desidera ottenere un valore.

@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 opera su Right

map trasforma il valore Right e lascia invariato un Left. Questo è il comportamento right-biased di Either in Scala (a partire dalla versione 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 valori predefiniti

getOrElse estrae il valore Right oppure restituisce un valore alternativo quando Either è un 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: invertire i lati

swap scambia Left e Right. È utile quando desidera operare sul lato dell'errore usando metodi right-biased.

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

isLeft e isRight

Rapidi controlli booleani consentono di diramare l'esecuzione senza ricorrere a un pattern matching completo.

  • isRight restituisce true in caso di successo.
  • isLeft restituisce true in caso di errore.
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: scartare l'errore

Quando non le interessa più perché qualcosa è fallito, toOption converte un Either in un Option: Right(x) diventa Some(x) e Left(_) diventa 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)
}

Un esempio di validazione

Mettiamo insieme i concetti: validare un nome utente, restituendo un errore tipizzato in caso di fallimento.

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 rapida

Verifichi la sua comprensione delle convenzioni di Either.

Riepilogo

Ha imparato a modellare gli errori con Either:

  • Right = successo, Left = errore (right-biased).
  • Usi il pattern matching o fold per elaborare il risultato.
  • Trasformi il risultato positivo con map e fornisca valori predefiniti con getOrElse.
  • Inverta i lati con swap e converta con toOption.

Successivamente gestirà le eccezioni con Try.

Domande Frequenti

La lezione «Either per gli errori» è gratuita?

Sì — il testo completo di «Either per gli errori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Either per gli errori»?

Left e Right Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Either per gli errori»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Either per gli errori
  2. Try, Success, Failure
  3. Comporre Either
  4. Convertire tra tipi
← Torna a Scala for Backend Engineering & Functional Programming