Scala for Backend Engineering & Functional Programming · Leçon

Définir des instances

Instances implicites

Leçon 2 sur 413 étapes

Définir des instances est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 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.

Définir des instances

Une instance indique au compilateur comment une classe de types se comporte pour un type donné. En Scala, les instances sont généralement marquées implicit (Scala 2) ou déclarées avec given (Scala 3), afin d’être trouvées automatiquement.

Une instance val implicite

Pour une classe de types simple, un implicit val suffit. Le compilateur le trouve lorsqu’une fonction a besoin d’un Show[Int].

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"Int=$a"

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(123))
  }
}

implicitly : demander une instance

implicitly[Show[Int]] demande au compilateur de récupérer l’instance présente dans la portée. C’est utile pour vérifier qu’une instance existe ou pour y accéder directement.

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"<$a>"

  def main(args: Array[String]): Unit = {
    val s = implicitly[Show[Int]]
    println(s.show(8))
  }
}

Instances pour des types personnalisés

Définissez une instance pour votre propre classe de cas. La classe de données reste épurée ; la mise en forme réside dans l’instance.

trait Show[A] { def show(a: A): String }

case class Point(x: Int, y: Int)

object Main {
  implicit val pointShow: Show[Point] = (p: Point) => s"(${p.x}, ${p.y})"

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(Point(3, 4)))
  }
}

implicit def pour les instances génériques

Lorsqu’une instance dépend d’une autre instance, utilisez implicit def. Ici, un Show[List[A]] est construit à partir d’un Show[A].

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => a.toString

  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString("[", ", ", "]")

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(List(1, 2, 3)))
  }
}

Instances dans l’objet compagnon

Placer les instances dans l’objet compagnon de la classe de types permet de les trouver automatiquement, sans aucun import. C’est l’emplacement recommandé pour les instances par défaut.

trait Show[A] { def show(a: A): String }

object Show {
  implicit val intShow: Show[Int] = (a: Int) => s"i:$a"
  implicit val strShow: Show[String] = (a: String) => s"s:$a"
}

object Main {
  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(5))
    println(display("hi"))
  }
}

Portée et priorité des implicites

Le compilateur recherche une instance à plusieurs endroits : d’abord dans la portée locale ou importée, puis dans les objets compagnons des types concernés. Si deux instances sont aussi spécifiques l’une que l’autre, vous obtenez une erreur d’implicite ambigu.

Abréviation de contrainte de contexte

La syntaxe def f[A: Show](a: A) est une contrainte de contexte : elle signifie qu’un Show[A] implicite doit être présent dans la portée. À l’intérieur, récupérez-le avec implicitly.

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"n=$a"

  def display[A: Show](a: A): String = implicitly[Show[A]].show(a)

  def main(args: Array[String]): Unit = {
    println(display(77))
  }
}

Un utilitaire pour demander une instance

Les bibliothèques ajoutent une méthode apply au compagnon comme outil de demande pratique : Show[Int] renvoie l’instance. C’est plus propre que implicitly.

trait Show[A] { def show(a: A): String }

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = (a: Int) => s"=$a"
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(10))
  }
}

Éviter les instances orphelines

Une instance orpheline est définie avec ni la classe de types ni le type. Elles sont autorisées, mais peuvent entraîner un comportement incohérent selon les imports. Préférez les instances dans les objets compagnons pour préserver leur cohérence.

Assembler le tout

Un programme complet : des instances dans les objets compagnons, une instance de liste dérivée et un outil de demande.

trait Show[A] { def show(a: A): String }

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = _.toString
  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString(", ")
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[List[Int]].show(List(4, 5, 6)))
  }
}

Vérification rapide

Testez vos connaissances sur la définition des instances.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris à définir des instances :

implicit val pour les instances simples, implicit def pour les instances dérivées.
Demandez une instance avec implicitly ou avec un apply compagnon.
Utilisez les contraintes de contexte [A: Show] comme abréviation.
Placez les instances dans des objets compagnons pour éviter les instances orphelines.

Gratuit pour commencer

Apprends Scala avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 39
Leçons: 143

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Définir des instances » est-elle gratuite ?

Oui — le texte complet de « Définir des instances » 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 « Définir des instances » ?

Instances implicites 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 2 sur 4.

Combien de temps prend la leçon « Définir des instances » ?

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

← Retour à Scala for Backend Engineering & Functional Programming