Kotlin والبرمجة الوظيفية
تقدّم Kotlin نفسها لغة متعددة النماذج، والبرمجة الوظيفية (FP) أحد النماذج التي تدّعيها. فما مقدار هذا الادعاء الذي يصمد عمليًا؟ وهل يمكن كتابة Kotlin وظيفية اصطلاحية دون مكتبات خارجية؟ لنتحقق.
عندما أفكر في البرمجة الوظيفية تخطر لي ثلاثة أشياء: عدم القابلية للتغيير (immutability) والـ monads والآثار الجانبية. عدم القابلية للتغيير يستحق سمعته الطيبة – فهو يجعل الشيفرة أسهل في الاستدلال عليها والتزامن (concurrency) أكثر أمانًا. والـ monads؟ قوية لكنها مرهبة. والآثار الجانبية؟ أي برنامج مفيد يحتويها. فهو يقرأ الملفات ويستدعي واجهات API ويكتب في قواعد البيانات. والسؤال الحقيقي ليس كيف نتخلص منها، بل كيف نبقيها تحت السيطرة.
تقدّم Kotlin نفسها لغة متعددة النماذج، والبرمجة الوظيفية أحد النماذج التي تدّعيها. فما مقدار هذا الادعاء الذي يصمد عمليًا؟ وهل يمكن كتابة Kotlin وظيفية اصطلاحية دون مكتبات خارجية؟
لمن هذه المقالة؟
إذا كانت عدم القابلية للتغيير والدوال من الرتبة الأعلى مألوفة لك، فتابع القراءة. لن أتناول map وfilter. وإذا كنت فضوليًا لمعرفة مدى وظيفية Kotlin حقًا، أو سئمت ببساطة من الإجابة «يعتمد على الحالة»، فهذه المقالة لك. وإذا كنت متمرسًا بالفعل في أنظمة الآثار (effect systems)، فمعظم ما هنا مألوف لك، وإن كان التمييز بين FP العرضية (casual) والنقية (pure) قد يفيدك.
ما الذي يجعل اللغة «وظيفية»؟
قبل تقييم Kotlin علينا أن نتفق على مقياس. البرمجة الوظيفية ليست خانة اختيار بنعم أو لا. بل هي أقرب إلى طيف، في أحد طرفيه «أستخدم map أحيانًا» وفي الطرف الآخر «كل شيء هو IO monad».
وهناك تمييز مفيد هنا: توجد FP العرضية وتوجد FP النقية. تعني FP العرضية معاملة الدوال كمواطنين من الدرجة الأولى (تمريرها كمعاملات وإعادتها من دوال أخرى)، واعتماد عدم القابلية للتغيير، واستخدام الدوال من الرتبة الأعلى، ونمذجة المجال بأنواع البيانات الجبرية، وتفضيل التعابير على العبارات عمومًا. أما FP النقية فتذهب خطوة أبعد: يتتبع نظام الأنواع الآثار الجانبية، وتُفرض الشفافية المرجعية (referential transparency)، ويصبح البرنامج كله في جوهره تركيبًا من دوال نقية.
ما الخلاصة المثيرة للاهتمام؟ معظم المكاسب العملية تأتي من الدخول إلى منطقة FP العرضية. فالانتقال من الشيفرة الأمرية إلى FP العرضية قفزة أكبر من الانتقال من العرضية إلى النقية. تحصل على شيفرة أنظف وأخطاء أقل وقابلية اختبار أفضل. أما التحول إلى FP النقية فيجلب ضمانات رياضية، لكن العائد على الاستثمار في معظم تطبيقات الأعمال مشكوك فيه.
FP العرضية: حيث تقدّم Kotlin أداءً جيدًا
سنبدأ بما تقدمه Kotlin للبرمجة الوظيفية العرضية. ويشمل ذلك الأساسيات التي تحتاجها معظم الفرق: عدم القابلية للتغيير والدوال النقية والدوال من الرتبة الأعلى وأنواع البيانات الجبرية.
عدم القابلية للتغيير
تفصل Kotlin المجموعات القابلة للتغيير عن غير القابلة له وتعزز عدم القابلية للتغيير من خلال طريقة تصميم اللغة.
val users = listOf(
User("Alice", 28),
User("Bob", 35)
)
تنتج listOf() قائمة غير قابلة للتغيير. وبعد إنشائها لا يمكن إضافة عناصر أو حذفها أو تغييرها.
val updatedUsers = users + User("Charlie", 42)
تؤدي إضافة عنصر إلى قائمة جديدة وتترك الأصلية سليمة.
data class User(val name: String, val age: Int)
الفئة data class ذات الخصائص val غير قابلة للتغيير افتراضيًا. ومع الطريقة copy() يجعل ذلك نمذجة مجال غير قابل للتغيير أمرًا طبيعيًا.
لا تفرض Kotlin عدم القابلية للتغيير عليك (فـ var وmutableListOf() لا يزالان متاحين)، لكنها تمنحك الأدوات وتوجّهك في الاتجاه الصحيح. وتذكّر أن val يجعل المرجع فقط غير قابل للتغيير، لا بنية البيانات الأساسية. وتستخدم المكتبة القياسية مجموعات غير قابلة للتغيير افتراضيًا.
الدوال النقية
يمكن كتابة الدوال النقية في أي لغة، بما فيها Kotlin.
fun processOrder(order: Order): Order {
return order.copy(
total = calculateDiscount(order.total, order.discountPercent)
)
}
بفضل الطريقة copy() في فئات البيانات، يأتي نمط «أعد نسخة معدّلة بدل التغيير» بشكل طبيعي. وعلى عكس Haskell، لا تفرض Kotlin النقاء وقت الترجمة. أي أنه لا شيء في المترجم يمنعك من إدخال آثار جانبية في دالة.
الدوال من الدرجة الأولى ومن الرتبة الأعلى
في Kotlin الدوال مواطنون من الدرجة الأولى. يمكن تمريرها كمعاملات وإعادتها من دوال أخرى وحفظها في متغيرات.
val square: (Int) -> Int = { it * it }
fun applyTwice(f: (Int) -> Int, x: Int): Int {
return f(f(x))
}
val result = applyTwice(square, 3) // 81
هنا تأخذ دالة من الرتبة الأعلى دالة أخرى كمعامل. يتيح هذا النمط تجريدات قوية، مثل map وfilter وتدفق تحكم مخصص. وهو حجر أساس في البرمجة الوظيفية، وتدعمه Kotlin بأناقة عبر صياغة lambda وأنواع الدوال.
عمليات FP في المكتبة القياسية
توفر المكتبة القياسية لـ Kotlin دعمًا واسعًا للعمليات الوظيفية على المجموعات:
data class Product(val name: String, val price: Double, val inStock: Boolean)
val products = listOf(
Product("Laptop", 999.0, true),
Product("Mouse", 25.0, false),
Product("Keyboard", 75.0, true)
)
val affordableInStock = products
.filter { it.inStock } // (1)
.filter { it.price < 100 } // (2)
.map { it.name.uppercase() } // (3)
.sorted() // (4)
// Result: ["KEYBOARD"]
- الاحتفاظ بالعناصر المتوفرة في المخزون فقط
- التصفية بحسب السعر
- التحويل إلى أسماء بأحرف كبيرة
- الترتيب أبجديًا
تتضمن واجهة المجموعات map وfilter وflatMap وfold وreduce وgroupBy وpartition وغيرها الكثير. وفي التحويلات الوظيفية اليومية لن تشعر بأنك مقيَّد.
أنواع البيانات الجبرية (ADTs)
تدعم Kotlin أنواع البيانات الجبرية بشكل جيد جدًا عبر الفئات/الواجهات sealed وفئات data.
sealed interface PaymentResult {
data class Success(val transactionId: String) : PaymentResult
data class Declined(val reason: String) : PaymentResult
data object NetworkError : PaymentResult
}
هذا نوع مجموع (sum type) (واجهة sealed)، حيث تأخذ النتيجة شكل واحد من عدة متغيرات. وللمتغيرات التي لا تحمل بيانات استخدم data object.
fun handlePayment(result: PaymentResult): String = when (result) {
is PaymentResult.Success -> "Payment successful: ${result.transactionId}"
is PaymentResult.Declined -> "Payment declined: ${result.reason}"
is PaymentResult.NetworkError -> "Network error, please retry"
}
تعبير when شامل – يتأكد المترجم من تغطية كل حالة. أضف متغيرًا جديدًا وسيتوقف ترجمة كل تعبير when لا يتعامل معه.
هذا مشابه تقريبًا لأنواع المجموع في لغات مثل Scala أو Rust. والتحقق من الشمولية بواسطة المترجم مفيد بشكل خاص: فعند إضافة متغير جديد، يشير المترجم إلى كل تعبير when يجب تحديثه.
مطابقة الأنماط
بالنسبة للأنواع المختومة (sealed)، يوفر تعبير when في Kotlin مطابقة أنماط شاملة:
sealed interface ApiResponse<out T> {
data class Success<T>(val data: T) : ApiResponse<T>
data class Error(val code: Int, val message: String) : ApiResponse<Nothing>
data object Loading : ApiResponse<Nothing>
}
fun <T> renderResponse(response: ApiResponse<T>): String = when (response) {
is ApiResponse.Success -> "Data: ${response.data}"
is ApiResponse.Error -> "Error ${response.code}: ${response.message}"
ApiResponse.Loading -> "Loading..."
} // Compiler checks exhaustiveness
وفي معظم حالات الاستخدام هذا قادر جدًا: تحصل على أمان الأنواع والتحقق من الشمولية، فتُكتشف الحالات المفقودة وقت الترجمة.
تحسين الاستدعاء الذيلي (Tail Call Optimization)
تدعم Kotlin بالفعل تحسين الاستدعاء الذيلي، لكن فقط عبر التعليق التوضيحي الصريح tailrec وتحت قيود صارمة.
tailrec fun factorial(n: Long, acc: Long = 1): Long =
if (n <= 1) acc
else factorial(n - 1, n * acc)
يجب أن تضيف التعليق التوضيحي tailrec. ويجب أن يقع الاستدعاء العودي في موضع ذيلي، أي أن يكون العملية الأخيرة في الدالة.
factorial(10000) // Works without stack overflow
مع tailrec يحوّل المترجم العودية إلى حلقة، فلا تؤدي العودية العميقة إلى فيضان المكدس.
القيود:
- ينطبق فقط على العودية المباشرة (العودية المتبادلة غير مدعومة)
- يجب أن تكون الدالة
privateأوfinalأو محلية - يجب أن يكون الاستدعاء العودي هو العملية الأخيرة
قارن ذلك بـ Scala، حيث يُطبَّق TCO تلقائيًا على الاستدعاءات في الموضع الذيلي. والتعليق التوضيحي الصريح في الواقع ميزة خفية: فإذا كتبت عودية غير ذيلية عن طريق الخطأ، يخبرك المترجم فورًا بدلًا من تركها تفشل وقت التشغيل.
قابلية الإلغاء الآمنة من حيث النوع (Type-Safe Nullability)
بدلًا من أنواع Option/Maybe المعتادة في لغات FP، تعتمد Kotlin على الأنواع القابلة للإلغاء (T?).
fun findUser(id: String): User? = userRepository.find(id)
نوع إرجاع قابل للإلغاء – اللاحقة ? تعبّر صراحةً عن الغياب في نظام الأنواع.
val username = findUser("123")?.name?.uppercase()
سلاسل من عامل الاستدعاء الآمن (?.) – فعندما تعطي أي خطوة null، تُقصَّر السلسلة كلها إلى null.
val username = findUser("123")?.name?.uppercase() ?: "Unknown"
يوفر عامل Elvis (?:) قيمة افتراضية كلما كان الطرف الأيسر null.
هذه المقاربة تعمل وآمنة من حيث النوع، لكنها ليست مكافئة لـ Option<T>. فـ Option يمنحك طرقًا مثل map وflatMap وfold، تحوّله إلى monad حقيقي:
// Kotlin nullable — imperative style
val user: User? = findUser("123")
val department = user?.department?.name ?: "Unknown"
// Option style (not in Kotlin stdlib)
val user: Option<User> = findUser("123")
val department = user
.flatMap { it.department }
.map { it.name }
.getOrElse { "Unknown" }
في معظم المواقف العملية تكفي الأنواع القابلة للإلغاء في Kotlin، وفي الحالات البسيطة يمكن القول إنها أسهل قراءة. لكن عندما تريد ربط عدة عمليات قابلة للفشل بأسلوب وظيفي، تصبح الأنواع القابلة للإلغاء مرهقة. وينتهي بك الأمر إلى كتابة كتل ?.let { } متداخلة.
FP النقية: ما المفقود؟
لنوضح ما تفتقر إليه Kotlin في البرمجة الوظيفية النقية؛ ينبغي أن تكون على دراية بهذه الفجوات قبل الانغماس في مقاربة وظيفية نقية بالكامل.
مطابقة أنماط محدودة
تتعامل تعابير when جيدًا مع مطابقة الأنماط الأساسية، لكن Kotlin لا تملك guards ولا تفكيكًا (destructuring) في عبارات المطابقة:
// Not possible in Kotlin
when (result) {
is Success(data) if data.isEmpty() -> ... // Guards not supported
is Error(404, _) -> ... // Can't destructure in when
}
الحل البديل: ضع الشروط المتداخلة داخل الفروع:
when (result) {
is ApiResponse.Success -> {
if (result.data.isEmpty()) "Empty data"
else "Data: ${result.data}"
}
is ApiResponse.Error -> {
if (result.code == 404) "Not found"
else "Error: ${result.message}"
}
ApiResponse.Loading -> "Loading..."
}
إنه أكثر إسهابًا لكنه يؤدي الغرض. إن غياب guards مصدر إزعاج لا عائق – فيمكن دائمًا التعبير عن المنطق نفسه، لكن بتداخل أعمق.
لا تركيب دوال مدمج
لا توفر Kotlin عوامل مدمجة لتركيب الدوال. ويجب إجراء التركيب يدويًا:
val addOne: (Int) -> Int = { it + 1 }
val double: (Int) -> Int = { it * 2 }
// Manual composition (works but reads right-to-left)
val addThenDouble = { x: Int -> double(addOne(x)) }
// Better: write your own extension
infix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C = { g(this(it)) }
val composed = addOne andThen double // (1)
composed(5) // 12
التركيب بدالة امتداد مخصصة
توفر لغات مثل Scala الدالتين compose وandThen جاهزتين. وفي Kotlin إما أن تكتب هذه الامتدادات بنفسك (5 أسطر من الشيفرة) أو تضيف مكتبة. الحل البديل بسيط، لكن من المفاجئ أن المكتبة القياسية لا تتضمنه.
لا نوع either/result أصلي للأخطاء
تملك Kotlin بالفعل نوع Result<T>، لكنه بُني خصيصًا لتغليف الاستثناءات ولا يستطيع تمثيل أنواع أخطاء عشوائية:
fun divide(a: Int, b: Int): Result<Int> =
if (b == 0) Result.failure(ArithmeticException("Division by zero"))
else Result.success(a / b)
divide(10, 0).getOrElse { -1 }
المشكلة: لا يمكن نمذجة أخطاء المجال بأناقة:
sealed interface ValidationError {
data object EmptyEmail : ValidationError
data object InvalidFormat : ValidationError
data class TooLong(val maxLength: Int) : ValidationError
}
// What we want:
fun validateEmail(email: String): Either<ValidationError, Email>
// What Kotlin gives us:
fun validateEmail(email: String): Result<Email> // Can only hold Exception
في غياب Either<E, A> لا خيار أمامك سوى:
- رمي الاستثناءات (وهذا ليس وظيفيًا)
- إرجاع أنواع قابلة للإلغاء (مما يهدر معلومات الخطأ)
- كتابة نوع Either الخاص بك (مما يعني شيفرة نمطية متكررة)
- الاعتماد على مكتبة مثل Arrow
لا نظام آثار (effect system)
لا تملك Kotlin نظام آثار مدمجًا. ففي اللغات الوظيفية، تغلّف أنواع الآثار مثل IO<A> أو Option<A> أو Either<E, A> العمليات الحسابية وتعبّر عن خصائصها عبر النوع – فـ Option يمثل الوجود/الغياب، وIO عملية قد تكون لها آثار جانبية، وEither الفشل أو النجاح.
// Kotlin: no effect system
fun loadUser(id: String): User = userRepository.find(id)
النوع (String) -> User لا يقول شيئًا عما تفعله الدالة فعلًا. هل تجري عمليات إدخال/إخراج؟ هل قد تفشل؟ هل تسبب آثارًا جانبية؟
تجعل اللغات ذات أنظمة الآثار النوع صريحًا:
-- Haskell: IO effect
loadUser :: String -> IO User
// Scala with Cats Effect
def loadUser(id: String): IO[User]
يمثل IO عملية قد تكون لها آثار جانبية. فبدلًا من النتيجة نفسها، تعيد الدالة وصفًا للعمل المطلوب تنفيذه. ويُعدّ المُعدِّل suspend في Kotlin أقرب ما يكون إلى علامة أثر، لكنه يشير فقط إلى نقاط التعليق في الكوروتينات (coroutines)، لا إلى الآثار عمومًا:
لا أنواع من رتبة أعلى (higher-kinded types)
لا تدعم Kotlin الأنواع من الرتبة الأعلى (HKTs)، التي تتيح التجريد فوق منشئات الأنواع مثل List أو Option أو Either. وبدون HKTs يستحيل كتابة شيفرة عامة تعمل مع أي منشئ أنواع F[_]، مما يحد من مدى ما يمكنك بناؤه من تجريدات وظيفية عامة.
تتيح لك Scala كتابة دوال تعمل على أي نوع حاوية:
// Generic function that works with any F[_]
def transform[F[_]: Functor, A, B](fa: F[A], f: A => B): F[B] =
fa.map(f)
// Works with List, Option, Either, etc.
transform(List(1, 2, 3), _ * 2) // List(2, 4, 6)
transform(Some(5), _ * 2) // Some(10)
transform(Right(5), _ * 2) // Right(10)
تُقرأ صياغة F[ _ ] على أنها «F منشئ أنواع يأخذ معامل نوع واحدًا». وهي تتيح لك كتابة الشيفرة مرة واحدة وجعلها تعمل مع أي نوع شبيه بالحاويات.
لا توفر Kotlin أي طريقة للتعبير عن هذا التجريد. وسيتعين عليك كتابة تنفيذات منفصلة لـ List والأنواع القابلة للإلغاء وResult وهكذا.
. وفي الوقت الحالي لا توجد خطط لإضافة HKTs إلى Kotlin.
لا فئات أنواع (type classes)
الواجهات في Kotlin ليست فئات أنواع (آلية تُعرف أيضًا باسم تعدد الأشكال المخصص – ad-hoc polymorphism). فلا يمكنك إضافة تنفيذات بأثر رجعي ولا تعريف قوانين يجب أن تلتزم بها النسخ:
// Kotlin interface: must be declared when defining the class
interface Showable {
fun show(): String
}
// Can't make String showable without wrapping it
data class DisplayString(val value: String) : Showable {
override fun show() = value
}
تتيح لك Scala وHaskell تعريف نسخة من فئة نوع لأي نوع موجود دون المساس به:
trait Showable[A]:
extension (a: A) def show: String
val stringShowable = new Showable[String]:
extension (value: String) def show: String = value
توفر دوال الامتداد في Kotlin بعض المزايا نفسها؛ لكنها تُحلّ بشكل ساكن (وقت الترجمة، بحسب النوع المعلن).
الخلاصة
بوصفها لغة FP عرضية، تصمد Kotlin جيدًا. فهي تزوّدك بعدم القابلية للتغيير والدوال من الرتبة الأعلى وأنواع البيانات الجبرية ومطابقة الأنماط الشاملة. وبدون أي تبعيات خارجية يمكنك كتابة شيفرة نظيفة ووظيفية: مسارات تحويل البيانات ونماذج مجال غير قابلة للتغيير ومنطق أعمال نقي. وفي معظم الفرق والمشاريع يكفي ذلك.
وتقصّر Kotlin في منطقة FP النقية. فلا معالجة أخطاء بالأنواع سوى الاستثناءات، ولا تتبع للآثار، ولا فئات أنواع، ولا شفافية مرجعية يفرضها المترجم. ولتحصل على هذه الضمانات تحتاج إلى Arrow.
توصيتي: لا تحارب اللغة. استخدم الأنواع القابلة للإلغاء عندما تبقي الأمور أبسط، وارمِ الاستثناءات عندما يكون البديل أسوأ، واعتمد على الفئات المختومة (sealed) في نمذجة المجال. وللأساسيات مثل تركيب الدوال، اكتب امتداداتك الخاصة من 5 أسطر. لكن حين تجد نفسك تبني نوع Either مخصصًا، فقد حان وقت إدخال Arrow.
سيتناول الجزء 2 كيف تسدّ Arrow هذه الفجوات ومتى يؤتي إضافة هذه التبعية إلى مشروعك ثماره.