0Pricing
Scala for Backend Engineering & Functional Programming · Lezione

Convertire tra tipi

Option, Either, Try

Convertire tra tipi è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 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.

Tre modelli per gli errori

Scala offre tre tipi complementari per rappresentare l'assenza e gli errori:

  • Option — presenza o assenza (senza indicarne il motivo).
  • Either — successo o errore tipizzato.
  • Try — successo o eccezione generata.

Saperli convertire consente di adattare un'API a un'altra.

Da Option a Either

toRight converte un Option in un Either, fornendo un errore Left nel caso None. toLeft esegue la conversione inversa.

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

Da Either a Option

toOption scarta l'errore: Right(x) diventa Some(x) e Left(_) diventa None. Lo usi quando il motivo del fallimento non è più rilevante.

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

Da Try a Option

Try.toOption trasforma un Success in Some e un Failure in None, ignorando l'eccezione.

import scala.util.Try

@main def run(): Unit = {
  println(Try("7".toInt).toOption)
  println(Try("x".toInt).toOption)
}

Da Try a Either

Try.toEither produce un Either[Throwable, T]: Success diventa Right, mentre Failure diventa Left(throwable). In questo modo l'eccezione viene preservata come valore left tipizzato.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

Da Either a Try

Non esiste una conversione integrata diretta da Either a Try per un errore semplice, ma può costruirne una: racchiuda un Right in Success e un Left in un Failure che contiene un'eccezione.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

Da Option a Try

Converta un Option in un Try scegliendo un'eccezione per il caso vuoto. È utile quando un'API richiede un Try.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

Normalizzare una pipeline

Mescolare i tipi crea difficoltà. Un approccio comune consiste nel convertire tutto in Either con un tipo di errore uniforme fin dall'inizio, per poi comporre liberamente le operazioni.

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

getOrElse tra i tipi

Tutti e tre i tipi supportano getOrElse per estrarre un valore o fornire un valore predefinito. Spesso questo è il passaggio finale con cui si esce dal mondo della gestione degli errori.

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

Scegliere il tipo giusto

Linee guida:

  • Usi Option quando l'assenza non richiede spiegazioni.
  • Usi Either quando desidera un valore di errore specifico del dominio.
  • Usi Try ai confini del programma quando interagisce con codice Java o di libreria che genera eccezioni.

Esempio completo

Leggere codice che genera eccezioni con Try, convertirlo in Either per gli errori di dominio e infine in Option per un chiamante interessato solo alla presenza del valore.

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

Verifica rapida

Verifichi la sua conoscenza delle conversioni.

Riepilogo

Ha imparato a convertire tra Option, Either e Try:

  • Option.toRight → Either; Either.toOption → Option.
  • Try.toOption e Try.toEither collegano le eccezioni ai valori.
  • Normalizzi presto una pipeline usando un unico tipo di errore.
  • Scelga il tipo in base alla quantità di dettagli sull'errore di cui ha bisogno.

Domande Frequenti

La lezione «Convertire tra tipi» è gratuita?

Sì — il testo completo di «Convertire tra tipi» è 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 «Convertire tra tipi»?

Option, Either, Try 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 4 di 4.

Quanto tempo richiede la lezione «Convertire tra tipi»?

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