Scala for Backend Engineering & Functional Programming · Lektion

Scala 3 given/using

Moderne Syntax

Scala 3 given/using ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Moderne implizite Werte in Scala 3

Scala 3 ersetzt das überladene Schlüsselwort implicit durch eine klarere Syntax: given definiert einen impliziten Wert, und using deklariert einen impliziten Parameter. Dadurch ist die Absicht deutlich leichter zu erkennen.

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 ersetzt implicit val

Wo Scala 2 implicit val x: T = ... schrieb, verwendet Scala 3 given x: T = .... Damit wird ein für die implizite Auflösung verfügbarer Wert deklariert.

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 ersetzt implizite Parameter

Eine using-Klausel kennzeichnet eine Parameterliste als implizit. Der Compiler füllt sie anhand eines passenden given-Werts im Gültigkeitsbereich aus.

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

Benannte givens

Sie können den Namen eines given weglassen, wenn Sie nicht direkt darauf verweisen. Der Compiler findet den Wert weiterhin anhand seines Typs.

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

Mit summon einen Wert abrufen

Das Scala-3-Konstrukt summon[T] ersetzt implicitly[T]. Es ruft direkt den gegebenen Wert vom Typ T ab.

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

Unbenannte using-Parameter

Wenn Sie einen using-Parameter nur weiterreichen müssen, können Sie seinen Namen in der Klausel weglassen: (using Int). Rufen Sie ihn innerhalb der Funktion mit summon ab.

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 für Typeclasses

Die idiomatischste Verwendung von given/using sind Typeclasses. Definieren Sie ein Trait, stellen Sie eine given-Instanz bereit und fordern Sie sie mit using an.

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

Kontextgrenzen funktionieren weiterhin

Kontextgrenzen wie [A: Show] sind weiterhin verfügbar und werden in einen using-Parameter umgewandelt. Kombinieren Sie sie mit summon, um auf die Instanz zuzugreifen.

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

using-Argumente explizit übergeben

Sie können einen using-Parameter an der Aufrufstelle mit dem Schlüsselwort using explizit angeben und damit den im Gültigkeitsbereich vorhandenen given-Wert überschreiben.

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 bietet eine eigene Syntax zum Importieren von givens: import pkg.given oder import pkg.{given Show[Int]}. Dadurch werden implizite Imports ausdrücklich und bewusst sichtbar.

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

Warum die neue Syntax

In Scala 2 hatte das einzelne Schlüsselwort implicit mehrere unterschiedliche Bedeutungen. Scala 3 trennt das Konzept auf: given = bereitstellen, using = anfordern. Der Code wird klarer und Fehlermeldungen werden leichter verständlich.

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

Kurzer Test

Welche Schlüsselwörter ersetzen in Scala 3 implicit zum Bereitstellen und Anfordern von Werten?

Zusammenfassung

Sie haben givens und using in Scala 3 kennengelernt:

given stellt einen impliziten Wert bereit (ersetzt implicit val)
using deklariert einen impliziten Parameter
summon[T] ersetzt implicitly[T]
Givens können unbenannt sein und eignen sich ideal für Typeclasses
import pkg.given importiert sie ausdrücklich

Häufig gestellte Fragen

Ist die Lektion „Scala 3 given/using“ kostenlos?

Ja — der vollständige Text von „Scala 3 given/using“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Scala 3 given/using“?

Moderne Syntax Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Scala 3 given/using“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming