Scala for Backend Engineering & Functional Programming · درس

given/using في Scala 3

الصياغة الحديثة

given/using في Scala 3 درس مجاني في Scala for Backend Engineering & Functional Programming على CoddyKit. هذا هو الدرس 2 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Scala for Backend Engineering & Functional Programming، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Scala for Backend Engineering & Functional Programming 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

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

الأسئلة الشائعة

هل درس «given/using في Scala 3» مجاني؟

نعم — نص درس «given/using في Scala 3» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Scala for Backend Engineering & Functional Programming، انتقل إلى CoddyKit PRO. تتضمن دورة Scala for Backend Engineering & Functional Programming 4 دروس في المجموع.

ماذا ستتعلم في «given/using في Scala 3»؟

الصياغة الحديثة تتمرن على Scala for Backend Engineering & Functional Programming مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Scala for Backend Engineering & Functional Programming؟

لا تُشترط خبرة سابقة. Scala for Backend Engineering & Functional Programming على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 2 من أصل 4.

كم من الوقت يستغرق درس «given/using في Scala 3»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Scala for Backend Engineering & Functional Programming هذا؟

نعم. كل درس في Scala for Backend Engineering & Functional Programming يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى Scala for Backend Engineering & Functional Programming