0Pricing
Scala for Backend Engineering & Functional Programming · Leçon

Convertir entre les types

Option, Either, Try

Convertir entre les types est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Trois modèles d’erreur

Scala propose trois types complémentaires pour représenter l’absence et l’échec :

  • Option — présence ou absence (sans explication).
  • Either — réussite ou erreur typée.
  • Try — réussite ou exception levée.

Savoir passer de l’un à l’autre vous permet d’adapter une API à une autre.

D’Option à Either

toRight convertit un Option en Either en fournissant une erreur Left dans le cas None. toLeft effectue la conversion inverse.

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

D’Either à Option

toOption supprime l’erreur : Right(x) devient Some(x) et Left(_) devient None. Utilisez-le lorsque la raison de l’échec n’a plus d’importance.

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

De Try à Option

Try.toOption transforme un Success en Some et un Failure en None, en masquant l’exception.

import scala.util.Try

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

De Try à Either

Try.toEither produit un Either[Throwable, T] : Success devient Right et Failure devient Left(throwable). L’exception est ainsi conservée sous forme de valeur gauche typée.

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

D’Either à Try

Il n’existe pas de conversion intégrée directe d’un Either vers un Try avec une erreur simple, mais vous pouvez en construire une : encapsulez un Right dans un Success et un Left dans un Failure contenant une exception.

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

D’Option à Try

Convertissez un Option en Try en choisissant une exception pour le cas vide. C’est utile lorsqu’une API attend 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))
  }
}

Normaliser un processus

Mélanger les types crée des difficultés. Une approche courante consiste à tout convertir rapidement en Either avec un type d’erreur uniforme, puis à composer librement.

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 avec tous les types

Les trois types prennent en charge getOrElse pour extraire une valeur ou fournir une valeur par défaut. C’est souvent l’étape finale qui permet de sortir de la gestion des erreurs.

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

Choisir le bon type

Recommandations :

  • Utilisez Option lorsque l’absence ne nécessite aucune explication.
  • Utilisez Either lorsque vous souhaitez une valeur d’erreur propre au domaine.
  • Utilisez Try aux frontières avec du code Java ou de bibliothèque susceptible de lever des exceptions.

Exemple de bout en bout

Lisez du code susceptible de lever des exceptions avec Try, convertissez-le en Either pour représenter les erreurs métier, puis enfin en Option pour un appelant qui ne s’intéresse qu’à la présence d’une valeur.

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

Vérification rapide

Vérifiez vos connaissances sur les conversions.

Récapitulatif

Vous avez appris à convertir Option, Either et Try :

  • Option.toRight → Either ; Either.toOption → Option.
  • Try.toOption et Try.toEither font le lien entre les exceptions et les valeurs.
  • Normalisez rapidement un processus vers un seul type d’erreur.
  • Choisissez le type correspondant au niveau de détail d’erreur dont vous avez besoin.

Questions Fréquemment Posées

La leçon « Convertir entre les types » est-elle gratuite ?

Oui — le texte complet de « Convertir entre les types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Convertir entre les types » ?

Option, Either, Try Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Convertir entre les types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Either pour les erreurs
  2. Try, Success, Failure
  3. Composer Either
  4. Convertir entre les types
← Retour à Scala for Backend Engineering & Functional Programming