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

Kotlin 2.1 عن قرب – من الخروج غير المحلي إلى السلاسل النصية متعددة علامات الدولار

جاء نوفمبر 2024 بإصدار Kotlin 2.1. لنلقِ نظرة على بعض تغييرات اللغة التي رافقت الإصدار الجديد.

11 دقائق قراءة
Kotlinpattern matchingلغات البرمجةKotlinServerSide

كان العام الماضي مهمًا بالنسبة لـ Kotlin، إذ صدر الإصدار الرئيسي 2.0.0 في مايو. وقد جلب ميزات مثيرة كثيرة، وأبرزها مترجم K2 المستقر، لكنه بالكاد مسّ تصميم اللغة نفسها. ولم يعد الأمر كذلك عند صدور الإصدار 2.1.0 في نوفمبر الماضي. فرغم أنها لا تزال في مرحلة المعاينة، جاء هذا الإصدار بعدد من تغييرات اللغة التي تستحق نظرة أدق. يتناول هذا المقال الجديد في Kotlin 2.1، مع التركيز على ميزات اللغة المضافة حديثًا.

المتطلبات الأساسية

لا تزال بعض ميزات اللغة المضافة في Kotlin 2.1 (التي نتناولها لاحقًا في هذا المقال) في مرحلة المعاينة، لذا لا ينبغي الاعتماد عليها في شيفرة الإنتاج، فقد تغيّرها الإصدارات المستقبلية أو تلغيها. ولاستخدام هذه الميزات في مشروعك، عليك تفعيلها عبر خيارات المترجم. فمع Gradle مثلًا، ضع ما يلي في ملف البناء:

kotlin {
    compilerOptions {
        freeCompilerArgs.add("-X<feature-name>")
    }
    jvmToolchain(21)
}

يذكر القسم الخاص بكل ميزة لاحقًا اسم الميزة الذي يوضع بعد “-X” (فقط حين تحتاج الميزة إلى ذلك).

وإضافة إلى ذلك، يتطلب استخدام ميزات اللغة هذه في IntelliJ IDEA الإصدار 2024.3.0 أو أحدث مع تفعيل وضع K2. ولتفعيل وضع K2، انتقل إلى Settings → Languages & Frameworks → Kotlin وحدد خانة “Enable K2 mode” (ثم يجب إعادة تشغيل الـ IDE).

وبعد أن غطينا الأساسيات، لننظر إلى الميزات الجديدة التي يجلبها أحدث إصدار من Kotlin.

تغييرات في التعبير when في Kotlin 2.1

التعبير when في Kotlin طريقة مرنة للتحكم في تدفق البرنامج ويعالج شروطًا متعددة بإيجاز. ورغم قوته، فإنه يفتقر إلى قدرات مطابقة الأنماط الكاملة المألوفة من لغات مثل Scala. وقد جاء Kotlin 2.1.0 بتحسينات ترفع بعض هذه القيود. يتناول هذا القسم ما تغيّر في التعبير when.

فحوصات الشمولية للتعبيرات when مع الفئات المختومة (sealed classes)

يغيّر أحدث إصدار من Kotlin طريقة معاملة التعبيرات when ذات الموضوع (subject) مع معاملات الأنواع التي حدودها العليا مختومة. لننظر بالضبط ما الذي اختلف. للتوضيح، لنفترض أن لدينا فئة مختومة تصف النتائج الممكنة لطلب HTTP:

sealed class HttpRequestResult {
    data class Success(val code: Int, val body: String) : HttpRequestResult()
    data class Error(val code: Int, val errorMessage: String) : HttpRequestResult()
    object Timeout : HttpRequestResult()
    class ConnectionError() : HttpRequestResult()
}

بمجرد حصولنا على نتيجة الطلب، نود معالجتها بطريقة ما. ولتبسيط الأمر، لنفترض أننا نريد إنتاج تمثيل نصي بحسب نوع النتيجة. إحدى الطرق لذلك دالة معامل نوعها مقيّد بفئتنا المختومة – HttpRequestResult. وقبل Kotlin 2.1، كانت دالة كهذه قد تبدو كما يلي:

fun <T: HttpRequestResult> processHttpRequestResult(
    response: T,
    successMapper: (T) -> String,
    ): String =
    when (response  ) {
        is HttpRequestResult.Success -> successMapper(response)
        is HttpRequestResult.Error -> "Error returned by server ${response.code}: ${response.errorMessage}"
        is HttpRequestResult.Timeout -> "Connection Timeout"
        is HttpRequestResult.ConnectionError -> "Connection error"
         else -> "But, why??" // compilation error if else branch is missing
    }

لاحظ أن الفرع else إلزامي رغم أن الفروع أعلاه تغطي بالفعل كل حالات الفئة المختومة. وهذه غرابة في Kotlin قبل 2.1.0: إذ تتطلب فرع else في التعبير when مع معاملات الأنواع ذات الحدود العليا المختومة. وبدون الفرع else يفشل التجميع بهذا الخطأ:

“‘when’ expression must be exhaustive. Add an ‘else’ branch.”

يصلح Kotlin 2.1.0 ذلك، فلم يعد الفرع else ضروريًا:

fun <T: HttpRequestResult> processHttpRequestResult(
    response: T,
    successMapper: (T) -> String,
    ): String =
    when (response  ) {
        is HttpRequestResult.Success -> successMapper(response)
        is HttpRequestResult.Error -> "Error returned by server ${response.code}: ${response.errorMessage}"
        is HttpRequestResult.Timeout -> "Connection Timeout"
        is HttpRequestResult.ConnectionError -> "Connection error"
    }

هذا يوفر علينا بعض الأحرف غير الضرورية – فالتفاصيل الصغيرة مهمة! هذه الميزة مستقرة، فلا حاجة إلى تفعيل وضع المعاينة.

شروط الحراسة في when مع موضوع (ميزة معاينة “when-guards”)

بعد ذلك، لنفترض أننا نريد معالجة أخطاء تعتمد على رمز الخطأ، فتنتج تمثيلات نصية مختلفة لأخطاء 4XX وأخطاء 5XX. قبل Kotlin 2.1.0، كنت على الأرجح ستفعل ذلك بعبارات when أو if/else متداخلة:

fun processHttpRequestResult(response: HttpRequestResult): String =
    when (response) {
        is HttpRequestResult.Success -> "Success with code ${response.code} and body: ${response.body}"
        is HttpRequestResult.Error -> {
            when (response.code) {
                in 400..499 -> "Client's error ${response.code}: ${response.errorMessage}"
                500 -> "Server's error ${response.code}: ${response.errorMessage}"
                else -> "Other error returned by server ${response.code}: ${response.errorMessage}"
            }
        }
        is HttpRequestResult.Timeout -> "Connection Timeout"
        is HttpRequestResult.ConnectionError -> "Connection error"
    }

يجلب إصدار Kotlin الحالي «شروط الحراسة» (guard conditions) إلى تعبيرات أو عبارات when التي لها موضوع. وهي تتيح لك إرفاق شرط إضافي بفروع when، مما يجعل تدفق التحكم أكثر وضوحًا ويسطّح الشيفرة مقارنة بالنسخة المتداخلة أعلاه:

fun processHttpRequestResultWithGuard(response: HttpRequestResult): String =
    when (response) {
        is HttpRequestResult.Success -> "Success with code ${response.code} and body: ${response.body}"
        is HttpRequestResult.Error if response.code in (400..499) -> "Client's error ${response.code}: ${response.errorMessage}"
        is HttpRequestResult.Error if response.code in (500..599) -> "Server's error ${response.code}: ${response.errorMessage}"
        is HttpRequestResult.Error -> "Other error returned by server ${response.code}: ${response.errorMessage}"
        is HttpRequestResult.Timeout -> "Connection Timeout"
        is HttpRequestResult.ConnectionError -> "Connection error"
    }

بعض خصائص هذه الميزة:

  • لا تُنفَّذ شيفرة الفرع إلا حين يتحقق الشرط الأساسي وشرط الحراسة معًا.
  • يمكن أن تكون للفرع الواحد عدة شروط.
  • يمكن استخدام كل معامل منطقي متاح في تعبير if/else العادي (&&، ||، ! و in).
  • يمكن الجمع بين الفروع ذات شروط الحراسة والفروع العادية.

هل هذا تغيير كبير؟ ليس حقًا، لكنه يقرّب Kotlin من مطابقة الأنماط الموجودة في لغات أخرى. وتذكّر أن الميزة لا تزال في مرحلة المعاينة ويجب تفعيلها صراحةً (انظر قسم المتطلبات الأساسية).

الاستيفاء في السلاسل النصية متعددة علامات الدولار (ميزة معاينة “multi-dollar-interpolation”)

يجعل Kotlin كتابة السلاسل النصية متعددة الأسطر مع الاستيفاء (interpolation) مريحة. لكن تظهر المشكلة حين يجب أن تحتوي السلسلة على علامة $ حرفية، وهي العلامة التي يستخدمها Kotlin للاستيفاء. وكثيرًا ما تواجه ذلك مع JSON Schema، حيث تدل البادئة $ على كلمات مفتاحية لها معنى خاص. وحتى الآن، كانت هذه الحالات تتطلب حلًا بديلًا مثل ${‘$’}، مما قد يضر بقابلية قراءة الشيفرة:

val jsonSchema_beforeKotlin2_1_0 = """
    {
        "${'$'}id" : "https://example/schema/json"
        "items" : {
            "${'$'}ref" : "#/${'$'}defs/exampleReference",
        },
        "${'$'}defs" : {
            "fileRef" : {
                "exampleReference" : "string",
            }
        }
    }
""".trimIndent()

ولحسن الحظ، يتيح لك Kotlin 2.1.0 أن تقرر كم علامة دولار تبدأ الاستيفاء. تضع هذا العدد من علامات الدولار أمام سلسلتك متعددة الأسطر. وكل تسلسل يحتوي على هذا العدد بالضبط من علامات الدولار يصبح علامة استيفاء، بينما تُعامل التسلسلات الأقصر على أنها أحرف حرفية. وباستخدام هذا النهج، يبدو مخطط JSON لدينا هكذا:

val jsonSchema_multiDollarStringInterpolation = $$"""
    {
        "$id" : "https://example/schema/json"
        "items" : {
            "$ref" : "#/$defs/exampleReference",
        },
        "$defs" : {
            "fileRef" : {
                "exampleReference" : "$$fileRefType",
            }
        }
    }
""".trimIndent()

في هذه الحالة، بادئة الاستيفاء هي علامتا دولار، فلا حاجة إلى أي حلول بديلة لإخراج أسماء العقد الخاصة مثل $id. ويحدث الاستيفاء فقط حيث تظهر علامتا دولار، كما في $fileRefType. وتذكّر أن الميزة لا تزال في مرحلة المعاينة، ويجب تفعيل الميزة “multi-dollar-interpolation”.

break وcontinue غير المحليين (ميزة معاينة “non-local-break-continue”)

قبل Kotlin 2.1.0، كانت عبارات return غير المحلية تتيح لك مغادرة الدالة المحيطة من داخل lambda، بدلًا من مغادرة الـ lambda فقط. وهذا يبسّط تدفق التحكم، لأن استدعاء الـ lambda يمكنه الخروج فورًا من الدالة الخارجية. لكنه يتطلب تمرير الـ lambda إلى دالة inline. لنرَ ذلك عمليًا.

لنفترض أننا نبني معالج أحداث يتحقق مما إذا كان ينبغي معالجة حدث قبل أن يعالجه فعلًا. ولتبسيط الأمر، لنأخذ بعض الأحداث المألوفة من معالجة طلبات التجارة الإلكترونية، مع قائمة بأحداث نسمح بها بشكل اعتباطي:

enum class EventType {
    ORDER_CREATED,
    ORDER_CANCELLED,
    ORDER_COMPLETED,
    ORDER_PAID,
    ORDER_DELIVERED,
}

val allowedEvents = setOf(
    EventType.ORDER_CREATED,
    EventType.ORDER_CANCELLED,
    EventType.ORDER_COMPLETED,
)

قد تبدو نسخة مبسطة من الشيفرة التي تتحقق من الأحداث وتعالجها بعبارة return غير محلية كما يلي:

fun handleEvents(events: Set<Event>) {
    for (event in events) {
        validateEvent(event) { invalidEvent ->
            println("Invalid event $invalidEvent")
            return
        }
        println("Event $event is valid")
        // processing the event...
    }
}

private inline fun validateEvent(event: Event, onValidationError: (Event) -> Unit) {
    if (event.eventType !in allowedEvents) {
        onValidationError(event)
    }
}

هنا، تتظاهر الدالة handleEvents بمعالجة الأحداث فقط. ومنطق التحقق الاعتباطي موجود في الدالة validateEvent التي تقبل حدثًا وlambda من النوع (Event) -> Unit تُستدعى حين لا يكون الحدث مسموحًا به. ولتبسيط الأمر، تطبع الـ lambda رسالة فقط وتعود من الدالة المحيطة.

هذا التنفيذ بعيد عن المثالية، إذ يتوقف عن معالجة الأحداث بمجرد بلوغه أول حدث غير صالح، وهذا ليس السلوك المطلوب. لكن غرضه الوحيد إظهار أن عبارة return غير المحلية تتيح لنا مغادرة الدالة handleEvents من داخل lambda. وتذكّر أن هذا كان ممكنًا أصلًا قبل Kotlin 2.1.0.

لنتقدم خطوة ونغيّر متطلبات معالج الأحداث بحيث يطبع ملخصًا بعد معالجة جميع الأحداث. الآن لا يمكننا مجرد العودة من الدالة handleEvents. علينا مغادرة حلقة for أولًا ثم طباعة الملخص. وتتيح لنا عبارة break ذلك. لنستبدل return بـ break:

internal fun handleEvents(events: Set<Event>) {
    for (event in events) {
        validateEvent(event) { invalidEvent ->
            println("Invalid event $invalidEvent")
            break
        }
        println("Event $event is valid")
        // processing the event...
    }
    println("Processing finished. Summary:...")
}

يؤدي تجميع هذه الشيفرة بإصدار من Kotlin أقدم من 2.1.0 إلى خطأ (ويعتمد تحديدًا على إصدار Kotlin). أما بدءًا من Kotlin 2.1.0، فعبارات break غير المحلية متاحة في المعاينة ويمكن استخدامها بمجرد تفعيل الميزة (انظر قسم المتطلبات الأساسية). وبفضل ذلك، تُجمَّع الشيفرة وتتصرف كما هو مقصود: تتوقف حلقة for عند أول حدث غير صالح ويُطبع الملخص.

وسيلاحظ القرّاء ذوو العين الفاحصة أنه رغم أن الشيفرة تعمل، فإن المترجم يصدر تحذيرًا:

والسبب أن عبارة break هنا ملتبسة، ولا يستطيع المترجم معرفة ما إذا كان ينبغي أن تنهي حلقة for الخارجية أم حلقة داخلية قد توجد داخل الدالة validateEvent. ولأن validateEvent دالة inline، فإن شيفرتها تُلصق مباشرة في الدالة المستدعية أثناء التجميع. وهناك طريقتان لإزالة هذا الالتباس:

  • إضافة وسم (label) يوضح أي حلقة ينبغي إيقافها.
  • إضافة عقد callsInPlace يخبر المترجم بأن onValidationError لا تُستدعى داخل حلقة داخلية في validateEvent.

سنختار الخيار الأول ونضيف وسمًا. تُجمَّع هذه الشيفرة دون أي تحذيرات:

internal fun handleEvents(events: Set<Event>) {
    forEachEventLoop@ for (event in events) {
        validateEvent(event) { invalidEvent ->
            println("Invalid event $invalidEvent")
            break@forEachEventLoop
        }
        println("Event $event is valid")
        // processing the event...
    }
    println("Processing finished. Summary:...")
}

ومع ذلك، لا يزال المنطق غير صحيح تمامًا. فالمعالجة تتوقف عند أول حدث غير صالح، بينما نريد تخطي الأحداث غير الصالحة ومواصلة معالجة بقية الأحداث. وربما خمّنت أن عبارة continue غير المحلية تمنحنا ذلك بالضبط:

fun handleEvents(events: Set<Event>) {
    forEachEventsLoop@ for (event in events) {
        validateEvent(event) { invalidEvent ->
            println("Invalid event $invalidEvent")
            continue@forEachEventsLoop
        }
        println("Event $event is valid")
        // processing the event...
    }
    println("Processing finished. Summary:...")
}

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

تزيل هذه الميزة تناقضًا في Kotlin – فقد كانت عبارات return غير المحلية مسموحة سابقًا، لكن break وcontinue لم تكونا كذلك. ونتيجة لذلك، تصبح lambdas في Kotlin أقوى. وتذكّر أن break وcontinue غير المحليين لا يزالان في مرحلة المعاينة، لكن يُتوقع أن يصبحا مستقرين في إصدار Kotlin قادم (2.2.0).

الخلاصة

يجلب Kotlin 2.1 مجموعة من التحسينات الجديدة التي تجعل شيفرتك أخف وأكثر قابلية للقراءة وأكثر تعبيرًا. ويعزز الإصدار مكانة Kotlin لغةً حديثة ودودة للمطورين ويضيف عدة ميزات مهمة:

  • التعبير when المحسّن يوفر فحوصات شمولية أفضل للفئات المختومة، فيمكن الآن كتابة المنطق الشرطي بإيجاز أكبر، دون فروع else زائدة.
  • شروط الحراسة في التعبير when تتيح لك وضع تصفية إضافية مباشرة في تعبيرات when، مما يسطّح الشيفرة ويسهّل قراءتها.
  • الاستيفاء في السلاسل النصية متعددة علامات الدولار يسهّل التعامل مع علامات الدولار الحرفية في السلاسل متعددة الأسطر، وهو مفيد بشكل خاص لمخططات JSON وصيغ البيانات الأخرى التي تعتمد على علامة $.
  • break وcontinue غير المحليين يزيلان تناقضًا في Kotlin ويحسّنان تدفق التحكم داخل lambdas والحلقات المعقدة.

هذه الميزات اللغوية لا تجعل شيفرة Kotlin لديك أقوى فحسب، بل تمهّد الطريق أيضًا لميزات أكثر تقدمًا في الإصدارات القادمة. استمتع باكتشاف ما يجلبه Kotlin 2.1 وانظر بنفسك كيف يمكن لهذه التحسينات أن تغيّر طريقة تطويرك.

وبما أن هذا المقال يركز على ميزات اللغة، فإنه لا يصف كل تغيير في أحدث إصدار. وللاطلاع على القائمة الكاملة بالتغييرات، أوصي بقراءة ملاحظات الإصدار هذه.