Scala for Backend Engineering & Functional Programming · Leçon

given/using de Scala 3

Syntaxe moderne

given/using de Scala 3 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.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Modern implicits in Scala 3

Scala 3 replaces the overloaded implicit keyword with clearer syntax: given defines an implicit value, and using declares an implicit parameter. The intent is far easier to read.

object Main:
  given greeting: String = "Hello"
  def greet(name: String)(using g: String): String = s"$g, $name!"
  def main(args: Array[String]): Unit =
    println(greet("Ann"))

given replaces implicit val

Where Scala 2 wrote implicit val x: T = ..., Scala 3 writes given x: T = .... It declares a value available for implicit resolution.

object Main:
  given factor: Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))

using replaces implicit parameters

A using clause marks a parameter list as implicit. The compiler fills it from a matching given in scope.

object Main:
  given unit: String = "kg"
  def label(n: Int)(using u: String): String = s"$n$u"
  def main(args: Array[String]): Unit =
    println(label(75))

Anonymous givens

You can omit the name of a given when you never refer to it directly. The compiler still finds it by type.

object Main:
  given Int = 3
  def triple(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(triple(7))

Summoning with summon

Scala 3's summon[T] replaces implicitly[T]. It fetches the given value of type T directly.

object Main:
  given name: String = "Scala 3"
  def main(args: Array[String]): Unit =
    val n = summon[String]
    println(n)

Anonymous using parameters

If you only need to forward a using parameter, you can leave it unnamed in the clause: (using Int). Summon it inside with summon.

object Main:
  given Int = 100
  def boosted(x: Int)(using Int): Int = x + summon[Int]
  def main(args: Array[String]): Unit =
    println(boosted(5))

given for type classes

The most idiomatic use of given/using is type classes. Define a trait, provide a given instance, and require it with using.

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

object Main:
  given Show[Int] with
    def show(a: Int): String = s"Int($a)"

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

  def main(args: Array[String]): Unit =
    println(display(42))

Context bounds still work

Context bounds [A: Show] remain available and desugar to a using parameter. Combine with summon to access the instance.

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

object Main:
  given Show[String] with
    def show(a: String): String = s"Str($a)"

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

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

Passing using arguments explicitly

You can supply a using parameter explicitly with the using keyword at the call site, overriding the given in scope.

object Main:
  given Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))
    println(scale(5)(using 2))

given imports

Scala 3 has dedicated syntax to import givens: import pkg.given or import pkg.{given Show[Int]}. This makes implicit imports explicit and intentional.

object Instances:
  given Int = 5

object Main:
  import Instances.given
  def addBase(x: Int)(using b: Int): Int = x + b
  def main(args: Array[String]): Unit =
    println(addBase(10))

Why the new syntax

In Scala 2 the single keyword implicit meant several different things. Scala 3 splits the concept: given = provide, using = require. Code is clearer and errors are easier to understand.

object Main:
  given pi: Double = 3.14159
  def area(r: Double)(using p: Double): Double = p * r * r
  def main(args: Array[String]): Unit =
    println(area(2.0))

Quick Check

In Scala 3, which keywords replace implicit for providing and requiring values?

Recap

You learned Scala 3's given/using:

given provides an implicit value (replaces implicit val)
using declares an implicit parameter
summon[T] replaces implicitly[T]
Givens can be anonymous and ideal for type classes
import pkg.given imports them explicitly

Questions Fréquemment Posées

La leçon « given/using de Scala 3 » est-elle gratuite ?

Oui — le texte complet de « given/using de Scala 3 » 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 « given/using de Scala 3 » ?

Syntaxe moderne 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 « given/using de Scala 3 » ?

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