Kotlin/lambdas

الدوال من المرتبة الأعلى (Higher-Order Functions)

وهي الدوال التي تقبل دوالًا أخرى كمتحولاتٍ وسيطةٍ لها، أو تلك التي تُعيد (return) دوالًا أخرى كنتيجة لها، وكمثالٍ عنها لنأخذ الدالة lock()‎، وهي الدالة التي تقبل كائنًا lock ودالةً أخرى، حيث ستحصلُ الدالة على الكائن lock وتُنفِّذُ الدالةَ الوسيطةَ ثم تُحرِّر القفل في النهاية، كما في الشيفرة:

fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try {
        return body()
    }
    finally {
        lock.unlock()
    }
}

إنّ body هو من نوع دالة (وهو ‎() -> T) ومن الواضح أنّه دالةٌ خاليةٌ من المتحولات تعيد النوع T، وتُستدعَى في الجزء try حيث تكون محميةً (protected) عبر lock، وتُعاد قيمتها عبر الدالة lock()‎. ولدى استدعاء الدالة lock()‎ يمكن تمرير دالةٍ أخرى كمتحولٍ لها (راجع مرجعيّات الدوال [function references] )، مثل:

fun toBeSynchronized() = sharedResource.operation()

val result = lock(lock, ::toBeSynchronized)

ومن الأفضل بمثل هذه الحالة تمريرُ تعبير lambda بالشكل:

val result = lock(lock, { sharedResource.operation() })

إذ تتصف تعابير lambda بما يلي:

• يٌحاط التعبير بالقوسين {} دائمًا.
• تُعرَّف متحولاته (إن وُجدَت) قبل المعامل ‎->‎ (وقد يُحذَف نوع المتحولات).
• تتوضع البُنية (body) (إن وُجدَت) بعد المعامل ‎->‎ .

ويُصطلَح في Kotlin بأنّه إن كانت الدالة تقبل في متحولها الأخير دالةً أخرى ويُمرَّر تعبير lambda كمتحولٍ لها، فيجب أن يوضع خارج القوسين () كما في الشيفرة:

lock (lock) {
    sharedResource.operation()
}

وتُعدُّ الدالة map()‎ مثالًا آخر عن الدوال من المرتبة الأعلى وهي بالشكل:

fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
    val result = arrayListOf<R>()
    for (item in this)
        result.add(transform(item))
    return result
}

ويكون استدعاؤها بالشكل:

val doubled = ints.map { value -> value * 2 }

حيث أمكن حذف القوسين () لأنّ lambda هي المتحول الوحيد المُستخدَم في هذا الاستدعاء.

it: الاسم الضمني (implicit name) للمتحول الوحيد

ليس من الضروريّ وجود تصريح (declaration) الدالة إن كانت القيمة الحرفيّة (literal) لها بمتحولٍ وحيدٍ حيث ستُستخدَم التسمية it للتعبير عنها، بالشكل:

ints.map { it * 2 }

ويسمح هذا بكتابة شيفرةٍ بالنمط LINQ كما يلي:

strings.filter { it.length == 5 }.sortedBy { it }.map { it.toUpperCase() }

استخدام الشرطة السفليّة (_) للمتحولات غير المستخدمة (بدءًا من الإصدار 1.1)

إن لم تكن هناك حاجةٌ لأحد المتحولات الوسيطة في lambda فيمكن استخدام الرمز _ بدلًا من الاسم، بالشكل:

map.forEach { _, value -> println("$value!") }

التفكيك (Destructuring) في Lambdas (بدءًا من الإصدار 1.1)

راجع التصريح بالتفكيك (destructuring declarations) حيث ستجد شرحًا عن التفكيك في lambda.

الدوال السطريّة (Inline Functions)

قد تُستخدَم الدوال السطريّة لتحسين الأداء في الدوال من المرتبة الأعلى.

تعابير Lambda والدوال المجهولة (Anonymous Functions)

يُعدُّ كلٌّ من تعبير lambda والدالة المجهولة قيمةً دالةً حرفيّةً (function literal) وهي دالةٌ لا يُصرَّح عنها بل تُمرَّر كتعبيرٍ مباشرةً، كما في المثال الآتي:

max(strings, { a, b -> a.length < b.length })

إذ إنّ الدالة max هي دالةٌ من مرتبةٍ أعلى (higher order) لأنها تقبل دالةً في متحولها الثاني والذي هو "تعبيرٌ داليّ" أو بكلامٍ آخر هو "قيمة حرفيّة للدالة"، وهذا مكافئٌ للشيفرة:

fun compare(a: String, b: String): Boolean = a.length < b.length

القيم الحرفيّة للدوال مع المستقبِل (Function Literals with Receiver)

تتيح لغة Kotlin إمكانيّة استدعاء قيمة حرفيّة للدالة بكائنٍ مستقبِل مُحدَّدٍ، إذ يمكن -داخل بُنية قيمة الدالة الحرفيّة- استدعاء التوابع عبر الكائن المُستقبِل دون استخدام أيّ مقيّدات (qualifiers) إضافيّة، وهذا يماثل الدوال الإضافيّة (extension functions) التي تسمح بالوصول (accessing) إلى عناصر الكائن المستقبِل داخل بُنية الدالة، ومن أشهر الأمثلة عنها المُنشِئ الحافظ للنوع (type-safe builders).

نوع هذه القيم الحرفيّة للدالة (function literals) هو نوع دالةٍ مع المستقبِل، أي:

sum : Int.(other: Int) -> Int

إذ من الممكن استدعاؤها وكأنها تابعٌ للكائن المستقبِل بالشكل:

1.sum(2)

وتسمح صيغة الدالة المجهولة (anonymous function) بتحديد نوع المستقبِل للقيمة الحرفيّة للدالة مباشرةً، وهذا يفيد عند الحاجة إلى التصريح عن متحولٍ من نوع الدالة مع المستقبِل لاستخدامه فيما بعد، مثل:

val sum = fun Int.(other: Int): Int = this + other

كما يمكن إسناد القيمة غير الحرفيّة (non-literal) من نوع الدالة بالمستقبِل أو تمريرها كمتحولٍ بالموقع الذي تُتوقَّع فيه الدالة العاديّة، والتي تحتوي على متحول أولٍ إضافيِّ من نوع المستقبِل وبالعكس، فمثلًا: يكون النوعان String.(Int) -> Boolean و (String, Int) -> Boolean متوافقين في الشيفرة:

val represents: String.(Int) -> Boolean = { other -> toIntOrNull() == other }
println("123".represents(123)) // true

fun testOperation(op: (String, Int) -> Boolean, a: String, b: Int, c: Boolean) =
    assert(op(a, b) == c)
    
testOperation(represents, "100", 100, true) // OK

وعندما يكون من الممكن تحديد نوع المستقبِل من السياق العامّ فتستخدم حينئذٍ تعابير lambda كقيمٍ حرفيّةٍ للدوال مع المستقبِل، مثل:

class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()  // إنشاء الكائن المستقبِل
    html.init()        // تمرير الكائن المستقبِل إلى lambda
    return html
}


html {       // بداية lambda 
             // مع المستقبِل
    body()   // استدعاء تابع عبر الكائن المستقبِل
}

مصادر

• صفحة الدوال من المرتبة الأعلى وLambdas في التوثيق الرسميّ للغة Kotlin