Scala for Backend Engineering & Functional Programming · Pelajaran

given/using di Scala 3

Sintaks modern.

given/using di Scala 3 adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Implisit modern dalam Scala 3

Scala 3 mengganti kata kunci implicit yang memiliki banyak fungsi dengan sintaks yang lebih jelas: given mendefinisikan nilai implisit, sedangkan using mendeklarasikan parameter implisit. Maksudnya jauh lebih mudah dibaca.

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

Jika Scala 2 menulis implicit val x: T = ..., Scala 3 menulis given x: T = .... Ini mendeklarasikan nilai yang tersedia untuk resolusi implisit.

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 menggantikan parameter implisit

Klausa using menandai daftar parameter sebagai implisit. Kompiler mengisinya dari given yang cocok dalam lingkup.

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 anonim

Anda dapat menghilangkan nama given jika tidak pernah merujuknya secara langsung. Kompiler tetap menemukannya berdasarkan tipe.

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

Mengambil nilai dengan summon

summon[T] dalam Scala 3 menggantikan implicitly[T]. Ini mengambil nilai given bertipe T secara langsung.

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

Parameter using anonim

Jika Anda hanya perlu meneruskan parameter using, Anda dapat membiarkannya tanpa nama dalam klausa: (using Int). Ambil parameter tersebut di dalam dengan 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 untuk kelas tipe

Penggunaan given/using yang paling sesuai dengan gaya Scala adalah untuk kelas tipe. Definisikan sebuah trait, sediakan instans given, lalu minta dengan 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))

Batas konteks tetap berfungsi

Batas konteks [A: Show] tetap tersedia dan diuraikan menjadi parameter using. Gabungkan dengan summon untuk mengakses instans tersebut.

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

Meneruskan argumen using secara eksplisit

Anda dapat menyediakan parameter using secara eksplisit dengan kata kunci using di lokasi pemanggilan, sehingga menimpa given yang ada dalam lingkup.

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

Impor given

Scala 3 memiliki sintaks khusus untuk mengimpor given: import pkg.given atau import pkg.{given Show[Int]}. Ini membuat impor implisit menjadi eksplisit dan disengaja.

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

Alasan sintaks baru

Dalam Scala 2, satu kata kunci implicit memiliki beberapa arti berbeda. Scala 3 memisahkan konsep tersebut: given = menyediakan, using = meminta. Kode menjadi lebih jelas dan kesalahan lebih mudah dipahami.

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

Pemeriksaan singkat

Dalam Scala 3, kata kunci apa yang menggantikan implicit untuk menyediakan dan meminta nilai?

Rangkuman

Anda telah mempelajari given/using dalam Scala 3:

given menyediakan nilai implisit (menggantikan implicit val)
using mendeklarasikan parameter implisit
summon[T] menggantikan implicitly[T]
Given dapat anonim dan ideal untuk kelas tipe
import pkg.given mengimpornya secara eksplisit

Pertanyaan yang Sering Diajukan

Apakah pelajaran “given/using di Scala 3” gratis?

Ya — teks lengkap “given/using di Scala 3” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “given/using di Scala 3”?

Sintaks modern. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “given/using di Scala 3” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming