Scala for Backend Engineering & Functional Programming · Lezione

given/using in Scala 3

Sintassi moderna

Lezione 2 di 413 passaggi

given/using in Scala 3 è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 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 impliciti moderni in Scala 3

Scala 3 sostituisce la parola chiave sovraccarica implicit con una sintassi più chiara: given definisce un valore implicito, mentre using dichiara un parametro implicito. L'intento è molto più facile da leggere.

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

Dove Scala 2 scriveva implicit val x: T = ..., Scala 3 scrive given x: T = .... In questo modo dichiara un valore disponibile per la risoluzione degli impliciti.

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 sostituisce i parametri impliciti

Una clausola using contrassegna un elenco di parametri come implicito. Il compilatore lo completa usando un given corrispondente presente nell'ambito.

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

given anonimi

È possibile omettere il nome di un given quando non si deve mai farvi riferimento direttamente. Il compilatore lo trova comunque in base al tipo.

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

Recuperare un valore con summon

summon[T] di Scala 3 sostituisce implicitly[T]. Recupera direttamente il valore given di tipo T.

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

Parametri using anonimi

Se deve solo inoltrare un parametro using, può lasciarlo senza nome nella clausola: (using Int). Lo recuperi al suo interno con 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 per i type class

L'uso più idiomatico di given/using riguarda i type class. Definisca un trait, fornisca un'istanza given e la richieda con 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))

I context bound funzionano ancora

I context bound [A: Show] sono ancora disponibili e vengono desugared in un parametro using. Li combini con summon per accedere all'istanza.

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

Passare esplicitamente gli argomenti using

È possibile fornire esplicitamente un parametro using con la parola chiave using nel punto della chiamata, sostituendo il given presente nell'ambito.

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

Import dei given

Scala 3 dispone di una sintassi dedicata per importare i given: import pkg.given oppure import pkg.{given Show[Int]}. In questo modo gli import impliciti sono espliciti e intenzionali.

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

Perché la nuova sintassi

In Scala 2, l'unica parola chiave implicit aveva diversi significati. Scala 3 separa i concetti: given = fornire, using = richiedere. Il codice è più chiaro e gli errori sono più facili da comprendere.

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

Verifica rapida

In Scala 3, quali parole chiave sostituiscono implicit per fornire e richiedere valori?

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a conoscere given/using in Scala 3:

given fornisce un valore implicito (sostituisce implicit val)
using dichiara un parametro implicito
summon[T] sostituisce implicitly[T]
I given possono essere anonimi e sono ideali per i type class
import pkg.given li importa esplicitamente

Gratis per iniziare

Impara Scala con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 143

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «given/using in Scala 3» è gratuita?

Sì — il testo completo di «given/using in Scala 3» è 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 «given/using in Scala 3»?

Sintassi moderna 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 2 di 4.

Quanto tempo richiede la lezione «given/using in Scala 3»?

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

← Torna a Scala for Backend Engineering & Functional Programming