Scala for Backend Engineering & Functional Programming · Lekcja

Scala 3 given/using

Nowoczesna składnia

Scala 3 given/using to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Nowoczesne wartości niejawne w Scali 3

Scala 3 zastępuje przeciążone słowo kluczowe implicit czytelniejszą składnią: given definiuje wartość niejawną, a using deklaruje parametr niejawny. Zamiar jest znacznie łatwiejszy do odczytania.

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 zastępuje implicit val

Tam, gdzie Scala 2 zapisywała implicit val x: T = ..., Scala 3 zapisuje given x: T = .... Deklaruje to wartość dostępną podczas rozpoznawania wartości niejawnych.

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 zastępuje parametry implicit

Klauzula using oznacza listę parametrów jako niejawną. Kompilator uzupełnia ją na podstawie pasującej wartości given dostępnej w zakresie.

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

Nienazwane wartości given

Można pominąć nazwę wartości given, jeśli nie będzie używana bezpośrednio. Kompilator nadal znajdzie ją na podstawie typu.

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

Pobieranie wartości za pomocą summon

Scala 3 zastępuje implicitly[T] wyrażeniem summon[T]. Bezpośrednio pobiera ono wartość given typu T.

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

Nienazwane parametry using

Jeśli parametr using ma być tylko przekazywany dalej, można pozostawić go bez nazwy w klauzuli: (using Int). Wewnątrz można pobrać go za pomocą 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 dla klas typów

Najbardziej idiomatycznym zastosowaniem given/using są klasy typów. Należy zdefiniować trait, dostarczyć instancję given i wymagać jej za pomocą 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))

Ograniczenia kontekstowe nadal działają

Ograniczenia kontekstowe [A: Show] są nadal dostępne i rozwijają się do parametru using. Można połączyć je z summon, aby uzyskać dostęp do instancji.

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

Jawne przekazywanie argumentów using

Parametr using można przekazać jawnie za pomocą słowa kluczowego using w miejscu wywołania, zastępując wartość given dostępną w zakresie.

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

Importowanie wartości given

Scala 3 ma dedykowaną składnię importowania wartości given: import pkg.given lub import pkg.{given Show[Int]}. Dzięki temu importy niejawne są jawne i zamierzone.

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

Dlaczego wprowadzono nową składnię

W Scali 2 jedno słowo kluczowe implicit oznaczało kilka różnych rzeczy. Scala 3 rozdziela te pojęcia: given = dostarczanie, using = wymaganie. Kod jest czytelniejszy, a błędy łatwiejsze do zrozumienia.

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

Szybkie sprawdzenie

W Scali 3 które słowa kluczowe zastępują implicit podczas dostarczania i wymagania wartości?

Podsumowanie

Omówiono składnię given/using w Scali 3:

given dostarcza wartość niejawną (zastępuje implicit val)
using deklaruje parametr niejawny
summon[T] zastępuje implicitly[T]
Wartości given mogą być nienazwane i świetnie nadają się do klas typów
import pkg.given importuje je jawnie

Często zadawane pytania

Czy lekcja „Scala 3 given/using” jest bezpłatna?

Tak — pełny tekst „Scala 3 given/using” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Scala 3 given/using”?

Nowoczesna składnia Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Scala 3 given/using”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming