Kotlin: الثغرات وكيفية التغلب عليها
تعرّف على أبرز 5 ميزات تفتقر إليها لغة Kotlin والحلول العملية للالتفاف عليها.
Kotlin لغة برمجة حديثة ومصممة بعناية وعامة الأغراض، وهي تتحول إلى خيار جذاب لتطوير الويب. فهي توفر دعماً ممتازاً للبرمجة الوظيفية، وكوروتينات متكاملة، وبناء لغات مخصصة لمجال معين، والتحويل الذكي بين الأنواع، وكثيراً من المزايا الأخرى النادرة في لغات البرمجة السائدة. لكن للأسف لا شيء خالٍ من العيوب، ولدى Kotlin أيضاً بعض أوجه القصور التي قد يجدها المطورون المتقدمون مزعجة نوعاً ما.
لا يهدف هذا المقال إلى انتقاد اللغة. بل يسعى إلى إثارة النقاش حول هذه الميزات المفقودة، وتقديم حلول بديلة عملية، والمساهمة في تحسين اللغة. كما يصلح دليلاً موجزاً للمطورين القادمين من لغات أخرى، يشير إلى الميزات التي قد يفتقدونها وما يمكنهم استخدامه بدلاً منها.
لا يوجد مُعدِّل وصول package-private
من الطرق المعتادة لتنظيم شيفرة Java تقسيمها إلى حزم (packages)، تركّز كل منها على جزء من المجال. مُعدِّل الوصول الافتراضي هو package-private، لذا إذا تركت مُعدِّل الوصول دون تحديد، فلن يمكن الوصول إلى الصنف أو العضو إلا من داخل الحزمة نفسها. ولا يمكن الوصول إلى الحزمة إلا عبر أصناف/أعضاء محددة جعلها المطور عامة عمداً، وهي تعمل بمثابة واجهة الحزمة. ويتوافق هذا النهج مع إحدى الأفكار الأساسية في البرمجة كائنية التوجه – التغليف. لكن Kotlin تفتقر إلى هذا المُعدِّل، فلا يمكن تغليف الحزم على مستوى البنية النحوية.
فيما يلي مثال على هيكل مشروع Java كلاسيكي وكيف يعتمد على مُعدِّل الوصول package-private:
com/example/project/
├── api/
│ ├── PizzaEndpoints.java (public/package-private)
│
├── domain/
│ ├── pizza/
│ │ ├── PizzaFactory.java (public) // can be used in kitchen
│ │ ├── Pizza.java (public) // can be used in kitchen
│ │ ├── DefaultPizzaFactory.java (package-private)
│ │ ├── DoughFactory.java (package-private)
│ │
│ ├── kitchen/
│ │ ├── KitchenService.java (package-private)
│
├── infrastructure/
│ ├── DatabaseConfig.java (package-private)
ربما تركت Kotlin package-private لتجنّب خلق شعور زائف بالأمان. فهذا المُعدِّل لا يمنع الوصول من الوحدات الأخرى منعاً تاماً، إذ يمكن الوصول إلى الأعضاء إذا استخدمت وحدة أخرى اسم الحزمة نفسه. ومع ذلك لا أستطيع التفكير في مواقف كثيرة يسبب فيها ذلك مشكلة حقيقية. فهناك دائماً طريقة «ملتوية» للالتفاف على التغليف، لكن هذا لا يعني أنه ينبغي استخدامها. في رأيي، لا يزال package-private يقدم فوائد كثيرة رغم هذا الضعف. بل يمكن جعله أفضل من نسخة Java بإضافة ضمانات ضد هذا الالتفاف. لمعرفة المزيد، راجع المسألة المتعلقة بـتوفير مُعدِّل رؤية package-private والنقاش الدائر حولها.
للأسف لا يوجد حل بسيط لذلك، على الأقل على مستوى البنية النحوية. لدى Kotlin مُعدِّل وصول internal، لكنه يقيّد الوصول على مستوى الوحدة (module). وإنشاء وحدات لمجرد التحكم في رؤية إعلانات أصناف أو دوال معينة سيكون مبالغة، خصوصاً حين يحتاج إلى ذلك عدد قليل منها فقط. وهذا لا يعني أن تتجنب تقسيم مشروعك إلى وحدات – بل على العكس، فهو غالباً فكرة جيدة. ومع ذلك، فالتحكم الأدق في رؤية الإعلانات داخل الوحدة الواحدة أفضل. وإذا أردت فرض الوصول package-private مع ذلك، يمكنك تجربة Konsist (نظير ArchUnit في عالم Kotlin) لكتابة اختبارات معمارية تمنع الوصول إلى الأعضاء غير الموجودين في الواجهة من حزم أخرى. لكن هذا النهج محل جدل، وهو بوضوح أقل فعالية من دعم مدمج في بنية اللغة.
لا توجد أنواع اتحادية (union types)
تتيح لك الأنواع الاتحادية (union types) تعريف نوع يمثل واحداً من عدة أنواع غير مترابطة تماماً، دون الحاجة إلى الوراثة أو أي علاقة أخرى بينها. فمثلاً قد تُرجع الدالة أدناه إما Error أو String:
fun doSomething(): String | Error = // syntax not supported yet
if(...) "string" else Error("message")
// this is exhaustive - no `else` required
val finalResult = when(val result = doSomething()) {
is String -> result.doSomething()
is Error -> handleError(result)
}
كما قد تتوقع، تصلح هذه الميزة لـمعالجة الأخطاء الصريحة، وهي أسلوب شائع في نموذج البرمجة الوظيفية يتجنب الاستثناءات لأنها تُخلّ بنقاء الدوال وتجعل الشيفرة أقل قابلية للتنبؤ.
للأسف، لا تدعم Kotlin الأنواع الاتحادية بعد، مع أن الأصناف المختومة (sealed classes) تتيح الوصول إلى نتيجة مشابهة، كما يوضح المثال التالي:
sealed interface Result {
data class Success(val value: String) : Result
data class Error(val message: String) : Result
}
fun doSomething(): Result =
if(...) Result.Success("string") else Result.Error("message")
// this is exhaustive - no `else` required
val finalResult = when(val result = doSomething()) {
is String -> result.doSomething()
is Error -> handleError(result)
}
يعمل sealed interface جيداً هنا، لأنه يضمن ألا يرث من Result أي صنف آخر. ويمكن بعد ذلك استخدام هذا القيد في تعبير when لتغطية كل الحالات الممكنة بشكل شامل.
أكبر عيوب الأصناف المختومة هو كمية الشيفرة التي تتطلبها. ففي معالجة الأخطاء، يجب كتابة واجهة بنمط Result وأصنافها الفرعية من الصفر في كل مرة تحتاج فيها إلى نمذجة مجموعة مختلفة من النتائج البديلة لدالة ما. وهذا يجعل إعادة استخدام الشيفرة أصعب بكثير. تخيّل أنك تريد إضافة حالة ممكنة إضافية إلى النوع Result (مثل NetworkError إلى جانب FileError) لحالة واحدة فقط. عندها عليك أن تنسخ صنف Result بكامله مع جميع أصنافه الفرعية وتضيف صنفاً فرعياً آخر للحالة الجديدة. أما الأنواع الاتحادية فكانت ستجعل ذلك أسهل بكثير:
class ParsingError
class FileError
class Success;
fun doSomething(): ParsingError | Success // syntax error: union types
fun doSomethingElse(): ParsingError | FileError | Success
حل بديل محتمل آخر هو الصنف Either من Arrow:
fun doSomething(): Either<Success, ParsingError>
ضعفه الرئيسي أنه يدعم صنفين فقط، لذا ما زلت بحاجة إلى كتابة أصنافك الخاصة للأخطاء شديدة التخصص وقليلة القابلية لإعادة الاستخدام. كما قد يضر بقابلية القراءة لأنه أقل توافقاً مع أسلوب Kotlin المعتاد. وفضلاً عن ذلك، ورغم أن Arrow مكتبة قوية، فهي أيضاً وحش معقّد ذو كلفة إضافية كبيرة، ففكّر مليّاً قبل اعتمادها في مشروعك. فعلاً، لا تشبه Kotlin مع Arrow لغة Kotlin المعتادة – بل تتجه نحو لغات وظيفية أكثر مثل Scala. وما لم يكن لدى فريقك خبرة واسعة في البرمجة الوظيفية، أنصح بعدم استخدام هذه المكتبة – فبالنسبة لمعظم المطورين قد تجعل الشيفرة أصعب بكثير في المتابعة.
يمكن الاطلاع على الاقتراح والنقاش حول الأنواع الاتحادية هنا. كما يقترح تنفيذاً أشمل لتقاطع الأنواع (type intersection) الذي تدعمه Kotlin حالياً بشكل محدود جداً.
لا توجد كتلة multi-catch
بالحديث عن الأنواع الاتحادية… هل تعلم أن لدى Java في الواقع نسخة مقيّدة منها؟ إذ لا يمكن استخدامها إلا كمعاملات catch عند معالجة الاستثناءات. فبدلاً من كتابة عدة كتل catch هكذا:
try {
// ... throw ...
}
catch (final ClassNotFoundException ex1) {
// ... body ...
}
catch (final IllegalAccessException ex2) {
// ... body ...
}
يمكنك كتابة ما يلي بدلاً من ذلك:
try {
// ... throw ...
} catch (ClassNotFoundException | IllegalAccessException ex) {
// ...body ...
}
للأسف، لا تدعم Kotlin الأنواع الاتحادية بأي شكل، حتى في كتلة catch.
تقدم لك Kotlin بضع طرق للالتفاف على ذلك. أولاً، ينبغي لك على الأرجح تجنّب الاستثناءات تماماً حيثما أمكن. وإذا لم يكن ذلك ممكناً، يمكنك استخدام بنية كهذه:
try {
// ...
} catch (e: Exception) {
when(e) {
is ClassNotFoundException, is IllegalAccessException -> { /* ... */ }
else -> throw e
}
}
فقط لا تنسَ إعادة رمي أي استثناءات لا تطابق (else -> throw e) كي لا يُبتلع شيء بصمت. وإعادة الرمي هذه تجعل النهج غير مثالي، لكنه جيد بما يكفي لمعظم الحالات.
يمكن الاطلاع على النقاش حول إضافة كتل multi-catch في مسألة Kotlin هذه على YouTrack.
لا توجد مطابقة أنماط معقدة
أصبحت مطابقة الأنماط (pattern matching) جزءاً معيارياً من لغات البرمجة الحديثة. حتى Java أضافتها في JDK 21 بتوسيع إمكانيات تعبيرات switch. وتجعل مطابقة الأنماط الشيفرة أكثر إيجازاً وتصريحية، بما ينسجم جيداً مع مبادئ البرمجة الوظيفية. توفر Kotlin تعبير when القوي للتحكم في التدفق وفحص الأنواع لكنها لا توفر إمكانيات مطابقة الأنماط الكاملة الموجودة في لغات مثل Scala. فالتعبير يدعم فحص الأنواع ومقارنة القيم، مما يجعله مجرد بديل أكثر إيجازاً لسلاسل if-else if.
حصلت Kotlin مؤخراً على تحسين صغير مع ظهور شروط الحراسة (guard conditions) التجريبية في Kotlin 2.1.0، التي تتيح إرفاق شروط إضافية بفروع when:
sealed interface Ingredient {
data class Tomato(val ripe: Boolean) : Ingredient {
fun makeSauce() {}
}
data class Cheese(val type: String) : Ingredient {
fun meltCheese() {}
}
}
fun preparePizza(ingredient: Ingredient) {
when (ingredient) {
is Ingredient.Cheese -> ingredient.meltCheese()
is Ingredient.Tomato if ingredient.ripe -> ingredient.makeSauce()
else -> println("Unknown ingredient")
}
}
وهذا قريب جداً في الواقع من أنماط الحراسة التي توفرها Java 21، لكنه ما زال تجريبياً في Kotlin، لذا ربما لا ينبغي الاعتماد عليه في شيفرة الإنتاج. وإذا نظرنا إلى ما هو أبعد من Java، فإن لغات مثل Scala أو حتى Python توفر مطابقة أنماط أكثر تقدماً بكثير من Kotlin، وذلك أساساً لأن تعبير when في Kotlin لا يدعم التفكيك (destructuring).
الاقتراح والنقاش حول مطابقة الأنماط في Kotlin موجودان في مسألة Kotlin هذه على YouTrack.
لا يوجد تفكيك تكراري للإعلانات
بالبقاء مع موضوع التفكيك، تدعم Kotlin إعلانات التفكيك بشكل ممتاز، كما توضح الأمثلة التالية:
data class Result(val code: Int, val message: String)
fun doSomething() = Result(5, "OK")
// destructuring works automatically for data classes
val (statusCode, message) = doSomething()
// you can omit the variable name if you don't need it:
val (_, message) = doSomething()
// can be used in loops
val map = mapOf("key" to "value")
for ((key, value) in map) {
// ...
}
// can be used in lambdas
map.mapValues { (key, value) -> "<$key>$value</$key>" }
أما التفكيك التكراري (recursive destructuring)، أي للخصائص المتداخلة، فـغير مدعوم في Kotlin. فمثلاً لن تعمل الشيفرة التالية:
data class Person(val name: String, val age: Int)
data class Company(val name: String, val ceo: Person)
fun findCompanies(): Map<String, Company>
findCompanies() // syntax error \/
.map { (id, (companyName, ceo)) -> "$id: $companyName (CEO: $ceo)" }
كثيراً ما أصادف حالات أتمنى فيها لو كانت هذه الميزة متاحة، وهو أمر مزعج – خصوصاً أن لغات مثل Python توفرها، ولا يبدو أن إضافتها صعبة بشكل خاص. ومع ذلك، يمكن القول إنك إذا شعرت بالحاجة إلى التفكيك التكراري داخل جسم دالة lambda، فقد تحاول فعل الكثير في مكان واحد، مما يخاطر بجعل شيفرتك معقدة بلا داع.
لمعرفة المزيد عن اقتراح إضافة هذه الميزة إلى Kotlin، راجع مسألة Kotlin هذه على YouTrack. وإذا كنت ترى أنها إضافة جديرة بالاهتمام لـ Kotlin، ففكّر في التصويت لها.
الخاتمة
Kotlin لغة برمجة حديثة عامة الأغراض ممتازة، ترفع الإنتاجية بشكل ملحوظ وتجعل المطورين في الفرق أكثر سعادة 😉. وبطبيعة الحال لا شيء مثالي، وهناك دائماً مجال للتحسين. اخترت الميزات التي تناولها هذا المقال بناءً على تجربتي الشخصية مع مشاريع Kotlin الواقعية. ويبدو أن كثيراً من المطورين يشاركونني هذه الصعوبات، كما يدل العدد الكبير من الأصوات على YouTrack. وفي الوقت نفسه، لن أستغرب أن يفضّل بعض المطورين عدم إضافة هذه الميزات، لاعتقادهم أنها غير ضرورية. فإضافة الميزات إلى لغة برمجة مسألة دقيقة، وليس على مصممي اللغة تنفيذ كل ما يطلبه المجتمع، لأن ذلك سيزيد اللغة تعقيداً.
الحفاظ على البساطة ميزة قيّمة بحد ذاتها.
إذا كنت مهتماً، فهناك المزيد من طلبات الميزات في مسألة Kotlin هذه على YouTrack (قمت بتصفيتها وترتيبها لك مسبقاً). وإذا صادفت ميزات تتمنى أن تتوفر في اللغة، فأشجعك بشدة على التصويت لها. آمل أن تساعدك الحلول البديلة الموضحة هنا في التعامل مع هذه القيود في مشاريعك (أو على الأقل أن تتيح لك مشاركتي الألم). ورغم هذه العيوب الصغيرة، تبقى Kotlin متعة في العمل بها.