تقدير المشروع
← كل المقالات

ما الذي يمكن لمطوّري Java اكتسابه من Scala

تعرّفوا كيف تذهب Scala أبعد من ذلك، إذ تقدّم ميزات قوية مثل أمان الأنواع والمعاملات الضمنية والمعلومات المتاحة وقت الترجمة، وكلها تغيّر طريقة تطويركم على JVM.

16 دقائق قراءة
ScalaJavaآمن الأنواع

ظهرت JVM عام 1994 لتشغيل برامج Java، لكنها لم تعد منصة خاصة بـ Java وحدها منذ زمن بعيد. فهناك لغات كثيرة أخرى تستفيد من قدراتها، ومنها Scala. وإذا كنت مطوّر Java سمعتَ أو قرأتَ قليلًا عن Scala، فقد تفترض أن كل ما تقدمه هو بعض السكّر النحوي. في هذا المقال سأحاول إقناعك بأنها تقدم أكثر من ذلك بكثير.

هناك بعض السكّر النحوي أيضًا، من بين أمور أخرى، لكن هذا ليس موضوع المقال. سأركّز على 3 ميزات تفتقر إليها Java وهي، في رأيي المتواضع، الأقوى والأكثر تأثيرًا. وهي أمان الأنواع، والمعاملات والأصناف الضمنية (implicit)، والمعلومات المتاحة وقت الترجمة.

أمان الأنواع

هل Java آمنة الأنواع؟ بالتأكيد. لكن ماذا يعني ذلك فعلًا؟ هل أمان الأنواع مسألة “نعم أو لا”، أم أنه أقرب إلى طيف؟ بعبارة أخرى، هل يمكن أن تكون لغتان آمنتي الأنواع بينما إحداهما “أكثر أمانًا” من الأخرى؟ في رأيي المتواضع، نعم يمكن ذلك، وScala “أكثر أمانًا” من Java. والسبب يكمن في آليتي “التغاير المشترك” (covariance) و”التغاير المعاكس” (contravariance) المنفذتين للأنواع العامة (generic). فهما توفران وسيلة لتأسيس علاقات وراثة بين الأنواع استنادًا إلى نوعها العام. والمثال يشرح ذلك أفضل:

في Java، قائمة List من Integers ليست قائمة List من Objects، رغم أن كل Integer هو Object. والشيفرة التالية لا تُترجم:

List<Integer> listOfInts = new List();
List<Object> listOfObjects = listOfInts // compile time error

أما في Scala، فهذه الشيفرة تُترجم:

val listOfInts: List[Int] = List()
val listOfObjects: List[Object] = listOfInts

كيف ذلك؟ إنها تعمل لأن List في Scala متغايرة مشتركًا في نوع عناصرها (النوع العام). انظروا كيف يُصرَّح عن List في Scala:

sealed abstract class List[+A] extends AbstractSeq[A]

هل ترون إشارة + بجانب النوع العام؟ إنها تدل على أن List متغايرة مشتركًا في نوعها العام، أي أن List عناصرها من نوع فرعي من A هي نفسها نوع فرعي من List عناصرها من النوع A. قد يبدو هذا غامضًا بعد، لكن تابعوا معي. والأمثلة تأتي للإنقاذ:

قائمة List من التفاح هي نوع فرعي من قائمة List من الفاكهة:

val listOfApples: List[Apple] = List(grannySmith, goldenDelicious, gala)
val listOfFruits: List[Fruit] = listOfApples

وقائمة List من الكلاب هي نوع فرعي من قائمة List من الحيوانات:

val listOfDogs: List[Dog] = List(
  frenchBulldog, 
  goldenRetriever, 
  germanShepherd
)
val listOfAnimals: List[Animal] = listOfDogs

قائمة List من أي نوع A هي نوع فرعي من قائمة List من نوع أعلى من A. وكل هذه الإسنادات تعمل ولا يعترض المترجم. وبطبيعة الحال، لا يمكنك إسناد نوع أعلى إلى نوع فرعي: فالتعبير val listOfDogs = listOfAnimals لن يُترجم.

وبفضل هذه الآلية البسيطة، لا حاجة إلى تحويل قائمة من الأنواع الفرعية قبل إسنادها إلى val مصنَّف كقائمة من الأنواع الأعلى.

قائمة من الأنواع الفرعية

التغاير المعاكس هو القاعدة “العكسية”. ويُصرَّح عنه بإشارة ناقص (-)، والتعبير ParamType[-T] يقول إن ParamType متغايرة معاكسًا في نوعها العام T. بعبارة أخرى، ParamType[A] هو نوع فرعي من ParamType[B] عندما يكون B نوعًا أعلى من A. قد يبدو هذا بلا معنى، لكن له حالات استخدام جيدة أيضًا.

النوع الذي تقبله دالة (نوع معامل الدالة) مثال على نوع متغاير معاكسًا. فالدالة التي تأخذ معاملًا واحدًا وتعيد قيمة متغايرة معاكسًا في نوع معاملها ومتغايرة مشتركًا في نوع قيمتها المعادة. نعم، يمكن لنوع (Function1 هنا) أن يكون متغايرًا مشتركًا في معامل نوع ومتغايرًا معاكسًا في آخر. والدالة ذات المعامل الواحد تنفّذ السمة (trait) Function1 في Scala (تظهر هنا بصيغة مبسّطة):

trait Function1[-T1, +R]

إنها بوضوح متغايرة معاكسًا في نوع ومتغايرة مشتركًا في الآخر. والمتغاير معاكسًا (-T1) هو نوع المعامل الذي تأخذه الدالة، بينما المتغاير مشتركًا (+R) هو النوع الذي تعيده الدالة. لماذا أحدهما متغاير مشتركًا والآخر معاكسًا؟ كل شيء يتسق.

لنأخذ الصنف Apple الذي يمتد من Fruit، والصنف Horse الذي يمتد من Animal. والآن لنأخذ دالة بالتوقيع Animal => Apple (تقبل معاملًا واحدًا من النوع Animal وتعيد Apple)، مثل whatItLikes(animal: Animal): Apple التي تعيد نوع التفاح المفضل لدى حيوان.

بعد ذلك، تخيّلوا خدمة HorseService, يتطلب مُنشِئها دالة من النوع Horse => Fruit. وبفضل تغاير الأنواع، ما زال بإمكاننا تمرير الدالة whatItLikes! فهي متغايرة معاكسًا في نوع المعامل – Animal نوع أعلى من Horse – ومتغايرة مشتركًا في نوع القيمة المعادة – Apple نوع فرعي من Fruit – لذلك فهي مناسبة! وبعبارة أخرى، نوع الدالة Function1[Animal, Apple] هو نوع فرعي من Function1[Horse, Fruit].، لأن Animal نوع أعلى من Horse وApple نوع فرعي من Fruit. ويتضح ذلك عند النظر في مواضع استخدامها. فكما في المثال أعلاه، حين تُطلب دالة تقبل Horse وتعيد Fruit، يمكننا مع ذلك تقديم دالة تقبل أي Animal (لأنها تقبل أي Horse أيضًا) وتعيد Apple (لأن Apple مقبول دائمًا حيث يُتوقع Fruit).

وهذا منطقي لأنه، بوجه عام، يمكن تمرير معامل إلى دالة تقبل نوعه الأعلى، وتُقبل القيمة التي تعيدها الدالة إذا كانت نوعًا فرعيًا من النوع المتوقع.

Horse => Fruit

نحن مطوّري Scala نادرًا ما نضطر إلى التعامل مع تغاير الأنواع في عملنا اليومي، لكن المكتبات التي نعتمد عليها تستخدمه، مما يجعلها أكثر فائدة وأمانًا (بمعنى أمان الأنواع) ويجنّبنا بعض أخطاء وقت التشغيل.

المعاملات الضمنية (Implicits)

الـ implicit قيمة أو معامل أو دالة يطبّقها المترجم تلقائيًا (ضمنيًا) في أي موضع تدعو إليه الحاجة، دون أن يظهر صراحةً في الشيفرة. فمثلًا، لاستدعاء دالة مصرَّح عنها كما يلي:

def encode[A](a: A)(using enc: Encoder[A])

يكفي كتابة encode(a)، شرط وجود مُرمِّز (encoder) ضمني لنوع a ضمن النطاق. وسيملأ المترجم المعامل enc نيابةً عنا.

للوهلة الأولى تبدو الـ implicits سكّرًا نحويًا – إذ يستطيع المبرمجون تجاوز بعض المعاملات لأن المترجم يوفرها تلقائيًا. لكنها، بفضل الدوال الضمنية (التحويل التلقائي من معامل إلى آخر)، أقوى بكثير مما تبدو.

في Scala 3 عدة أنواع من الـ implicits – المعاملات الضمنية والتحويلات والامتدادات وغيرها. وسنلقي نظرة سريعة على كل منها، ثم نحاول بناء شيء مفيد بالجمع بين أنواع مختلفة من الـ implicits في Scala 3.

المعامل الضمني

يتيح لك هذا تجنّب كتابة اسم المتغير في كل مرة يلزم فيها. وهو مفيد للمعاملات التي تُمرَّر من دالة أعلى مستوى إلى أدنى، ثم إلى أدنى منها، وهكذا. فأمور مثل السياق والقيم الافتراضية والمهل الزمنية (timeouts) وغيرها تنشأ عادةً في الأعلى لكنها مطلوبة على مستويات عدة أبعد. وبدلًا من تمريرها يدويًا، يمكنك جعلها ضمنية فتُمرَّر تلقائيًا:

@main
def main(): Unit = {
 given timeout: Timeout = Timeout(3)

 val value = doSomething
 println(value)
}

def doSomething(using Timeout) = {
 doSomethingDeeper
}

def doSomethingDeeper(using timeout: Timeout): String = {
 s"done in less than ${timeout.seconds} seconds"
}

لست بحاجة إلى تمرير timeout إلى doSomething أو إلى doSomethingDeeper – فهو يُسلَّم تلقائيًا. وإذا لم يُستخدم معامل ضمني صراحةً داخل نطاق ما فلا يحتاج إلى اسم – انظروا كيف يُصرَّح عن doSomething: فيها using Timeout دون اسم معامل، فقط للإشارة إلى أن المعامل الضمني مطلوب دون تسميته. وهذا يشبه إلى حد ما ScopedValue في Java، إلا أنه يجب التصريح عنه في كل دالة على مسار الاستدعاء – ففي المثال أعلاه تصرّح doSomething أيضًا بمعامل Timeout الضمني رغم أنها لا تستخدمه. ومن ناحية أخرى، لا تقتصر الـ implicits على المعاملات – فهناك أصناف ودوال ضمنية أيضًا، فتابعوا القراءة.

التحويل الضمني

أحيانًا يجب تحويل قيمة إلى نوع مختلف. لنفترض أنك تحتاج إلى تحويل Meters إلى Yards. مع وجود تحويل ضمني ضمن النطاق يمكن أن يحدث ذلك تلقائيًا: فيمكن حينها استخدام Meters حيثما يُتوقع Yards، وستُحوَّل أثناء التنفيذ!

case class Meters(value: Double)
case class Yards(value: Double)

given Conversion[Meters, Yards] = m => Yards(m.value * 1.094)

@main
def main2(): Unit = {
 val distance = Meters(10)

 go(distance)
}

def go(distance: Yards): Unit = {
 println(s"Going ${distance.value} yards")
}

مع أن go تأخذ Yards بدل Meters، فإنها تعمل بفضل التحويل الضمني. إذ تُحوَّل Meters الممرَّرة كوسيط إلى Yards.

دوال الامتداد

دوال الامتداد (extension methods) هي النوع الثالث من الـ implicits في Scala 3. ويمكنكم عدّها “تحويلًا إلى نوع تتوفر فيه الدالة”. لنفترض أن قيم Double تُستخدم في مكان ما، لكننا نريد أن نكون أدق وأكثر أمانًا من حيث الأنواع، بضمان أن قيمة double معينة تمثل مسافة بـ Meters. يمكننا إضافة دالة امتداد .asMeters إلى النوع Double!

extension(distanceInMeters: Double) def asMeters(): Meters = 
  Meters(distanceInMeters)

@main
def main3(): Unit = {
 val distance = 10

 go(distance.asMeters())
}

وهذا يتيح توسيع سلوك نوع (إضافة دوال إليه) لا يتحكم فيه المبرمج – كنوع قادم من مكتبة مثلًا. وهناك طرق أخرى لتحقيق ذلك، مثل تغليف النوع في ValueObject، لكنني أرى أن دوال الامتداد هي الخيار الأفضل. فميزتها أن النوع الواحد يمكن أن تكون له دوال امتداد كثيرة (ربما من مكتبات مختلفة)، بينما تعدد الـ ValueObjects لنوع واحد أمر مربك. فالنوع المغلَّف في VO واحد لا يمكن تغليفه في VO آخر في الوقت نفسه. ويتطلب الأمر فك التغليف ثم إعادته في VO مختلف، وهذا غير مريح.

المعلومات المتاحة وقت الترجمة

تكشف Java كثيرًا من المعلومات عن الأصناف وحقولها ودوالها وغيرها أثناء التشغيل. وهذا يتيح مُرمِّزات ومُسلسِلات عامة وغيرها، لكن إن حدث خطأ – كأن يُتوقع حقل ولا يملكه الصنف – فسيفشل ذلك أثناء التشغيل. أما Scala 3 فتتيح معلومات أكثر بكثير وقت الترجمة، فإذا لم تتحقق افتراضات معينة فإن الشيفرة ببساطة لن تُترجم.

Mirror

تُوفَّر المعلومات عن case class (وهو يشبه record في Java) وأنواع حقوله عبر Mirror.Of[A] – وهو نوع يُبنى وقت الترجمة ويحمل هذه المعلومات على شكل أنواع أخرى. وكل شيء هنا يعيش على مستوى الأنواع لا على مستوى القيم، ومتاح وقت الترجمة. ويتيح لك الحصول على اسم نوع الـ case class وأنواع حقوله وتسمياتها وغير ذلك.

constValue

constValue دالة في الحزمة scala.compiletime تعيد قيمة نوع ثابت. وما النوع الثابت؟ إنه نوع له قيمة واحدة ممكنة فقط. فعندما تنشئون قيمة في Scala 3 مثل

val a = 1

يكون نوع a هو Int، لكنه أيضًا 1. نعم، 1 هنا نوع – وهو يمتد من Int بوضوح، وعادةً لا نحتاج إليه ونستخدم Int فقط، لكنه نوع مميز مع ذلك. إنه نوع ثابت بقيمة واحدة ممكنة: 1. لذا فإن constValue دالة تعيد قيمة – أي النسخة (الوحيدة) – من هذا النوع.

تعمل constValue فقط في سياق inlined، لأن النوع الممرَّر يجب أن يكون معروفًا وقت الترجمة. وسنعود إلى inline لاحقًا.

erasedValue

تعيش erasedValue أيضًا في scala.compiletime، وتنتج “نسخة افتراضية” من نوع وقت الترجمة. وهي مفيدة حين تحتاجون إلى معلومات عن نوع لا توجد قيمته أصلًا أثناء التشغيل – فتنشئ erasedValue مثل هذه القيمة الافتراضية. وسنستخدمها لمطابقة الأنماط على أنواع أعضاء الـ case class المأخوذة من Mirror.Of.

inline

الدالة المضمَّنة (inline) هي دالة يستبدل المترجم استدعاءها بجسم الدالة. وفي مثالنا سنستخدم inline match، الذي يُختزل وقت الترجمة إلى فرع واحد فقط من مطابقة الأنماط. فمثلًا

inline b match {
 case true => "matches!"
 case false => "no match, sorry"
}

سيُستبدل وقت الترجمة بـ "matches!" أو "no match, sorry" مباشرة. وبطبيعة الحال، لكي ينجح ذلك يجب أن تكون قيمة b معروفة وقت الترجمة أيضًا؛ وإلا فسيُصدر المترجم خطأ.

لنبنِ شيئًا مفيدًا

للوهلة الأولى قد تبدو الـ implicits مجرد سكّر نحوي لا يوفر علينا سوى بعض الكتابة. لكنها، إذا استُخدمت بحكمة، قد تكون أداة قوية. ويمكن أن تُحدث ضررًا عند إساءة استخدامها – اعتبروا أنفسكم محذَّرين ;) ومن الاستخدامات (الجيدة) للـ implicits توليد المُرمِّزات/فاكّات الترميز والمُسلسِلات/فاكّات التسلسل. وأكثرها شيوعًا مُرمِّزات JSON وفاكّاته، لكن أي صيغة أخرى مثل CSV وProtobuf وغيرها تصلح أيضًا. وJSON مناسب لأنه بلا مخطط (schema-less) ويدعم الكائنات المتداخلة، مما يتيح فرصة لإظهار كيف تساعد الـ implicits في توليد مُرمِّزات متداخلة. وفي هذا المثال سنبني شيئًا أبسط، لكنه بلا مخطط ومتداخل مثل JSON تمامًا. والمُرمِّز عام ويعمل مع أي case class (وهي تشبه record في Java، هل تذكرون؟) تحتوي case classes متداخلة أخرى. حسنًا، ربما ليس أي واحدة – فالسمات (traits) والمجموعات وغيرها غير مدعومة – لكنه يكفي لإظهار ما تستطيع الـ implicits فعله. لنأخذ case classes بسيطتين

case class User(name: String, age: Int, address: Address)

و

case class Address(
  country: String, 
  city: String, 
  street: String, 
  number: Int
)

لن نستخدم أي انعكاس أثناء التشغيل. وإذا حدث خلل وتعذّر ترميز نسخة، فنريد أن نعرف ذلك وقت الترجمة.

هدف آخر هو سهولة الاستخدام، على نحو تقريبي كالتالي:

val user = User(
  "Paul", 
  45, 
  Address("Germany", "Hamburg", "Lindenstrasse", 10)
)
val encoded = Encoder.encode(user)

من الواضح أننا نحتاج إلى كائن Encoder فيه دالة encode

object Encoder {
   def encode[A](value: A)(using enc: Encoder[A]): String = ...

في Scala، الـ object هو singleton. وفيه تضعون الدوال التي ستكون static في java – أي التي لا تتطلب نسخًا من الأصناف. ويقول التصريح عن الدالة encode إنها تأخذ معاملًا “عاديًا” واحدًا هو value من النوع A، إضافة إلى معامل ضمني واحد من النوع Encoder[A].

داخل هذه الدالة، A نوع عام. ويمكن أن يكون أي نوع، والتصريح يحتاج إليه للمعامل enc. وenc هو Encoder مُهيَّأ بالنوع العام، الذي يجب أن يكون النوع نفسه الذي value نسخة منه. وهذا هو القيد الوحيد على النوع العام A هنا والسبب الوحيد لحاجتنا إليه – للتعبير عن أن النوع العام لـ Encoder يجب أن يطابق نوع value.

يقع enc في قائمة معاملات خاصة به – نعم، في Scala يمكن أن تكون للدالة أكثر من قائمة معاملات. والكلمة المفتاحية using تعلّم المعاملات في هذه القائمة بأنها ضمنية – أي لسنا مضطرين إلى كتابتها صراحةً إذا كان معامل ضمني من ذلك النوع ضمن النطاق.

الآن لنكتب جسم الدالة. وبمجرد توفر المُرمِّز المطلوب يبدو بسيطًا:

def encode[A](a: A)(using enc: Encoder[A]): String = enc.encode(a)

بهذه الطريقة تُستخدم المُرمِّزات الضمنية من النوع المناسب – وهذا يثبت فائدته عند ترميز الأنواع المتداخلة.

إذن يجب أن يكون Encoder ضمني للنوع A ضمن النطاق – لكن من أين يأتي؟ تُوفّره دالة ضمنية

inline implicit def makeEncoder[A](using m: Mirror.Of[A]): Encoder[A]

لجسم هذه الدالة نحتاج إلى بعض الأدوات الموصوفة سابقًا. ومهمة هذا المُرمِّز أن يُخرج اسم الصنف مع أسماء جميع أعضائه وقيمها – وهو شبيه بـ JSON لكنه أبسط: نحذف الأقواس المعقوفة ولا نهتم بالتنسيق. وكل هذه المعلومات نحصل عليها وقت الترجمة. لنرَ الدوال التي تفعل ذلك:

inline implicit def makeEncoder[A](using m: Mirror.Of[A]): Encoder[A] = 
  (a: A) => {
    val labels: Seq[String] = deconstructLabels[m.MirroredElemLabels]

   val memberEncoders: Seq[Encoder[Any]] = 
     deconstructMemberEncoders[m.MirroredElemTypes]

   val lines = a.asInstanceOf[Product].productIterator
     .zip(labels)
     .zip(memberEncoders)
     .map {
       case ((value, label), memberEncoder) =>
         s"$label: ${memberEncoder.encode(value)}"
     }

 constValue[m.MirroredLabel] + "\n" + lines.mkString("\n")
}

تعتمد الدالة makeEncoder على بضع دوال مساعدة للحصول على حقول الـ case class وأسمائها وأنواعها واسم الـ case class، وفي النهاية تبني String منسّقة بشكل جميل تحتوي كل ذلك.

يحمل labels تسميات الأعضاء، فمثلًا بالنسبة إلى Address ستكون “country” و“city” و“street” و“number”.

ويحمل memberEncoders مُرمِّزات لكل عضو في الـ case class، بالترتيب.

ومن الأمور اللافتة هنا a.asInstanceOf[Product]. فكل case class في Scala هي أيضًا نسخة من Product. وتوفر السمة Product الدالة productIterator – وهي مكرِّر على جميع حقول الـ case class. وبعد ضمّها مع labels (أسماء الحقول) وmemberEncoders يمكننا التعامل مع الحقول واحدًا تلو الآخر، لكل منها value وlabel وmemberEncoder.

والسطر الأخير من الدالة makeEncoder يضيف في البداية m.MirroredLabel فحسب، الذي يحمل اسم الـ case class.

الآن إلى القطعتين الأخيرتين الناقصتين – الدالتين deconstructLabels وdeconstructMemberEncoders.

inline def deconstructLabels[T <: Tuple]: List[String] =
 inline erasedValue[T] match
   case _: (head *: tail) =>
     constValue[head].asInstanceOf[String] :: deconstructLabels[tail]
   case _: EmptyTuple => List.empty

تنشئ الدالة أعلاه قيمة “افتراضية” (لا توجد فعليًا أثناء التشغيل) من النوع T، وهو هنا MirroredElemLabels من Mirror.Of. ثم تطابق الأنماط على نوعها. والنوع هو Tuple، ويمكنكم المطابقة عليه كما تفعلون مع قائمة – head وtail (وقد يكون tail قائمة فارغة) أو EmptyTuple. وبشكل تعاودي (recursive)، حين يكون head وtail (تذكروا أن كليهما نوعان لا قيمتان – هل تذكرون الأنواع الثابتة؟)، تقرأ head على أنه نسخة من String (فهذه تسميات، فهي دائمًا Strings) وتفكّك tail. وهكذا تُبنى قائمة بكل التسميات.

انظروا الآن إلى الدالة الأخرى – deconstructMemberEncoders. إنها أكثر تعقيدًا قليلًا، لكن تحملوني.

inline def deconstructMemberEncoders[T <: Tuple]: List[Encoder[Any]] =
 inline erasedValue[T] match
   case _: (head *: tail) =>
     val encoder = summonInline[Encoder[head]]
     encoder.asInstanceOf[Encoder[Any]] :: 
       deconstructMemberEncoders[tail]
   case _: EmptyTuple => List.empty

كما سبق، نحتاج إلى erasedValue للمطابقة على النوع T. ومرة أخرى، النوع العام T هو دائمًا tuple، لكنه هذه المرة tuple من أنواع الحقول لا من التسميات. فهي ليست كلها Strings بل أنواع مثل Int وString وAddress وغيرها. ولكل نوع عضو يُستدعى (summon) Encoder. والاستدعاء يعني الحصول على قيمة ضمنية إن وُجدت ضمن النطاق. وإن لم توجد، تفشل الترجمة – فكل الـ implicits تُحلّ وقت الترجمة لا أثناء التشغيل. ويجب أن تكون مُرمِّزات الأنواع الأولية (للتبسيط نستخدم String وInt) فقط) ضمن النطاق أيضًا، ونضيفها صراحةً. نعم… implicits، صراحةً… ولهذين النوعين نحتاج إلى أسطر كهذه:

given Encoder[String] with
   def encode(a: String): String = a

given Encoder[Int] with
   def encode(a: Int): String = a.toString

يعرّف هذا مُرمِّزين لـ String وInt، ويضعهما، عبر الكلمة المفتاحية given، ضمن النطاق كـ implicits. وEncoder الخاص بـ Address ضمن النطاق الضمني أيضًا، رغم أننا لم ننشئه قط! فالدالة الضمنية makeEncoder تنتجه تلقائيًا. وهذا ما قصدته بعبارة “بعض الـ implicits تُضاف إلى النطاق صراحةً”. فبعضها علينا كتابته يدويًا، بينما يُولَّد الخاص بـ Address بدالتنا السحرية.

وبعد اكتمال كل هذه القطع، صار لدينا أداة ترمّز أي case class أعضاؤها من النوع String أو Int، أو case classes متداخلة أخرى تحتوي أيضًا حقولًا من هذين النوعين. وكل ذلك وقت الترجمة! وإذا تُرجمت الشيفرة، فاستدعاء Encoder.encode(x) مضمون دائمًا أن يعيد سلسلة منسّقة بشكل جميل بكل المعلومات عن x.

الخلاصة

تقدّم Scala ميزات مميزة غائبة عن Java تتجاوز كثيرًا مجرد الراحة النحوية البسيطة. وأبرزها نظام أنواع متقدم يدعم التغاير في الأنواع العامة ويتيح تعددية شكلية أكثر متانة. وتتيح الـ implicits تمرير المعاملات والتحويلات بين الأنواع وتوليدها تلقائيًا، مما يجعل اشتقاق type classes للأنواع المتداخلة ممكنًا. وتساعد قدرات Scala وقت الترجمة، مثل الدوال المضمَّنة التي تكشف معلومات عن الأنواع، في اكتشاف الأخطاء مبكرًا وتحسين الأداء. وبمجموعها تجعل هذه الميزات من Scala خيارًا جذابًا لمطوّري Java الباحثين عن طريقة برمجة أكثر تعبيرًا وموثوقية.