0Pricing
Scala for Backend Engineering & Functional Programming · Lezione

Gestire gli errori in IO

handleError

Gestire gli errori in IO è 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.

Gli errori come valori

In Cats Effect, un IO può fallire. Il fallimento fa parte del valore, quindi può esaminarlo e recuperare da esso senza ricorrere a un try/catch non strutturato.

Sollevare errori

Usi IO.raiseError per creare esplicitamente un IO fallito con un'eccezione scelta.

import cats.effect.IO

val failed: IO[Int] =
  IO.raiseError(new RuntimeException("boom"))

handleError

handleError recupera da un IO fallito fornendo un valore alternativo calcolato a partire dall'errore. Il risultato è un IO che a questo punto non può fallire.

import cats.effect.IO

val safe: IO[Int] =
  IO.raiseError[Int](new RuntimeException("x"))
    .handleError(_ => -1)

handleErrorWith

handleErrorWith recupera usando un altro IO, quindi il valore alternativo può a sua volta produrre effetti, ad esempio registrare un log, riprovare o restituire un valore predefinito.

import cats.effect.IO

val recovered: IO[Int] =
  IO(throw new RuntimeException("fail"))
    .handleErrorWith(e => IO.println(s"caught: ${e.getMessage}").as(0))

attempt

attempt converte un IO[A] in IO[Either[Throwable, A]], trasformando l'errore in un valore che può analizzare con il pattern matching.

import cats.effect.IO

val e: IO[Either[Throwable, Int]] =
  IO.raiseError[Int](new RuntimeException("oops")).attempt

Pattern matching con attempt

Dopo attempt può distinguere tra successo e fallimento con un normale flatMap su Either.

import cats.effect.IO

val prog: IO[Unit] = IO(10 / 2).attempt.flatMap {
  case Right(v) => IO.println(s"ok: $v")
  case Left(e)  => IO.println(s"err: ${e.getMessage}")
}

redeem

redeem gestisce entrambi i casi in un'unica chiamata: una funzione per l'errore e una per il successo, entrambe con un valore semplice come risultato.

import cats.effect.IO

val label: IO[String] =
  IO(42).redeem(e => s"failed: $e", v => s"value: $v")

redeemWith

redeemWith è simile a redeem, ma ogni ramo restituisce un IO, consentendo di gestire con effetti sia il successo sia il fallimento.

import cats.effect.IO

val prog: IO[Unit] = IO(42).redeemWith(
  e => IO.println(s"err: $e"),
  v => IO.println(s"got: $v")
)

Pulizia garantita

guarantee esegue un finalizzatore indipendentemente dal fatto che l'effetto abbia successo o fallisca: è perfetto per rilasciare risorse o registrare il completamento.

import cats.effect.IO

val prog: IO[Int] =
  IO(compute()).guarantee(IO.println("done"))

def compute(): Int = 7

Riprovare in caso di fallimento

Può creare un semplice meccanismo di retry recuperando ricorsivamente con handleErrorWith e decrementando un contatore fino a raggiungere zero.

import cats.effect.IO

def retry[A](io: IO[A], n: Int): IO[A] =
  if (n <= 0) io
  else io.handleErrorWith(_ => retry(io, n - 1))

try/catch in Scala normale

Lo confronti con la gestione eager degli errori nella Scala tradizionale. I combinatori di IO offrono la stessa sicurezza, ma sotto forma di valori puri e componibili.

object Main {
  def main(args: Array[String]): Unit = {
    val result = try { 10 / 0 } catch { case _: ArithmeticException => -1 }
    println(s"result: $result")
  }
}

Verifica rapida

Quale metodo trasforma un IO[A] in IO[Either[Throwable, A]]?

Riepilogo

Ha gestito gli errori in IO con:

  • raiseError per causare esplicitamente un fallimento
  • handleError / handleErrorWith per recuperare
  • attempt per materializzare Either
  • redeem / redeemWith per gestire entrambi i rami
  • guarantee per la pulizia

Ha completato il corso su Cats e IO.

Domande Frequenti

La lezione «Gestire gli errori in IO» è gratuita?

Sì — il testo completo di «Gestire gli errori in IO» è 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 «Gestire gli errori in IO»?

handleError 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 «Gestire gli errori in IO»?

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. Type class di Cats
  2. La monade IO
  3. Comporre IO
  4. Gestire gli errori in IO
← Torna a Scala for Backend Engineering & Functional Programming