Higher-order function: یہ کیا ہے، خصوصیات اور Kotlin میں مثالیں

Higher-order function کیا ہے؟

Higher-order function ایک ایسا فنکشن ہے جس میں دو خصوصیات میں سے کم سے کم ایک موجود ہو: دوسرے فنکشن کو اعتراض کے طور پر لینا یا نتیجے کے طور پر فنکشن واپس کرنا۔ ریاضی میں، ایسے فنکشنز کو فنکشنل یا آپریٹر کہا جاتا ہے۔ پروگرامنگ میں، وے 1958 میں Lisp میں ظاہر ہوئے اور تمام جدید زبانوں — JavaScript، Python، Swift، Kotlin، Scala اور Haskell — کا لازمی حصہ بن گئے۔ Higher-order function ایک مخصوص عمل سے تجرید کرنے اور رویہ کو قدرت کے طور پر پاس کرنے کی اجازت دیتا ہے۔

Higher-order function اور عام فنکشن کے درمیان بنیادی فرق فنکشنل قسم کے پیرامیٹر یا واپس کیے گئے فنکشنل قدرت کی موجودگی ہے۔ Kotlin میں، فنکشنل قسم (ParamType) -> ReturnType کے طور پر لکھا جاتا ہے۔ مثال کے طور پر، قسم (Int) -> String ایک ایسا فنکشن ہے جو Int لیتا ہے اور String واپس کرتا ہے۔ قسم () -> Unit ایک ایسا فنکشن ہے جس میں کوئی پیرامیٹر نہیں ہے اور کوئی قابل قدرت واپس نہیں کرتا۔ یہ قسم کا نظام higher-order functions کو قسم محفوظ بناتا ہے۔

Higher-order function کا مخالف first-class function (فرسٹ کلاس فنکشن) ہے۔ First-class function کا مطلب ہے کہ ایک فنکشن کسی اور قدرت کی طرح استعمال کیا جا سکتا ہے: متغیر کو مقرر کیا جا سکتا ہے، کلکشن میں محفوظ کیا جا سکتا ہے، اعتراض کے طور پر پاس کیا جا سکتا ہے۔ Higher-order function ایک فنکشن ہے جو لینے یا واپس کرنے کے لیے first-class functions کا استعمال کرتا ہے۔ Kotlin اضافی لائبشریز کے بغیر زبان کی سطح پر دونوں تصورات کی حمایت کرتا ہے۔

Kotlin میں higher-order function کیسے کام کرتا ہے؟

Kotlin میں، کوئی بھی فنکشن جس میں کم سے کم ایک پیرامیٹر فنکشنل قسم کے ساتھ مقرر کیا گیا ہو یا جس کی واپسی قسم فنکشنل ہو، خودکار طور پر higher-order function سمجھا جاتا ہے۔ کامپائلر کو کسی خاص تشریح کی ضرورت نہیں ہے — دستخط میں (T) -> R کی وضاحت کافی ہے۔ ایسے فنکشن کو کال کرتے وقت، اعتراض ایک lambda اظہار، :: کے ذریعے موجودہ فنکشن کا حوالہ، یا متغیر میں محفوظ ایک فنکشنل قدرت ہیں.

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum = operate(10, 20) { x, y -> x + y }
    println(sum) // 30
}

فہرست میں، operate فنکشن دو عدد صحیح اور قسم (Int, Int) -> Int کا ایک op پیرامیٹر لیتا ہے۔ فنکشن کا بادن ایک سطر میں گذرے گئے آپریشن کو کال کرتا ہے۔ main میں، operate کا کال lambda { x, y -> x + y } گذرتا ہے — Kotlin trailing lambda سنٹیکس کی وجہ سے اسے قوسین کے بعد رکھتا ہے۔ اگر lambda آخری اعتراض ہوتا، تو اسے مکمل طور پر قوسین کے باہر لے جا سکتا ہے، جو کال کی زنجیروں کی خوانش پذیری میں بہتری کرتا ہے۔

پردے کے پیچے، Kotlin higher-order functions کو Function انٹرفیس کے ذریعے ترتیب دیتا ہے (دو پیرامیٹرز کے لیے Function2)۔ ہر lambda ایک گمنام کلاس میں تبدیل ہو جاتا ہے جو متبقہ FunctionN انٹرفیس کو نفذ کرتا ہے۔ اس کا مطلب ہے کہ lambda بنانے کے لیے ہر عمل کے لیے ایک آبجیکٹ مختص کرنا ضروری ہے۔ اس بوجھ کو کم کرنے کے لیے، Kotlin inline فنکشنز کی حمایت کرتا ہے، جو کال کی جگہ پر higher-order function کے بادن کو بدل دیتا ہے، گمنام کلاس کی تخلیق کو ختم کرتا ہے۔

پیرامیٹر کے طور پر فنکشن: رویہ گذاری

ایک فنکشن کو اعتراض کے طور پر پاس کرنا higher-order functions استعمال کا سب سے عام نمونہ ہے۔ پولی مارفک طریقے کے ساتھ کلاس کا درجہ بنانے کے بجائے، ڈیویلپر مطلوبہ رویہ کو سیدھا استعمال کے مقام پر گذارتا ہے۔ یہ وراثت کے بغیر آپن/کلوزڈ اصول کو نفذ کرتا ہے: ایک نیا عمل ایک نئے ذیلی کلاس کے طور پر نہیں، بلکہ ایک نئے lambda کے طور پر شامل کیا جاتا ہے۔

nullable فنکشنز کے لیے، Kotlin قوسین کے بعد سوالیہ کے نشان کے ساتھ ((T) -> R)? قسم استعمال کرتا ہے۔ ایسا فنکشن صرف null چیک کے بعد یا ?.invoke() آپریٹر کے ذریعے ہی کال کیا جا سکتا ہے۔ اس ماملے میں، higher-order function کا دستخط واضح طور پر بتاتا ہے کہ فنکشن گذارنا اختیاری ہے — کال کرنے والا کوڈ اعتراض کو چھوڑ سکتا ہے۔ یہ اختیاری رویہ کے ساتھ کال بیک اور ایونٹ ہینڈلرز کے لیے مفید ہے۔

fun <T> List<T>.customFilter(
    predicate: (T) -> Boolean
): List<T> {
    val result = mutableListOf<T>()
    for (item in this) {
        if (predicate(item)) result.add(item)
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val even = numbers.customFilter { it % 2 == 0 }
    println(even) // [2, 4]
}

اکسٹینشن فنکشن customFilter فنکشنل قسم (T) -> Boolean کا ایک predicate پیرامیٹر لیتا ہے۔ لوپ کے اندر، یہ ہر عنصر کے لیے predicate کو کال کرتا ہے اور مطابقت کرنے والوں کو اکٹھا کرتا ہے۔ main میں کال lambda { it % 2 == 0 } گذرتا ہے، جہاں it lambda کے واحد پیرامیٹر کا ضمنی نام ہے۔ Higher-order functions کی بدولت، فلٹرنگ لاجک کلکشن گردش کے میکانزم سے مکمل طور پر علاوہ ہے۔

واپسی قدرت کے طور پر فنکشن

Higher-order function ایک فنکشن واپس کر سکتا ہے — اس نمونے کو فنکشن فیکٹری یا رویہ جنریٹر کہا جاتا ہے۔ واپس کیا گیا فنکشن بیرونی دائرہ کار سے متغیروں کو کیپچر (بندش) کر سکتا ہے، انہیں کالوں کے درمیان محفوظ رکھتا ہے۔ یہ ترتیب دےنے قابل ہینڈلرز اور مشترک سانچوں پر مبنی مختص عملیات بنانے کی اجازت دیتا ہے۔

فنکشن واپس کرتے وقت، Kotlin دستخط سے واپس کیئے گئے فنکشنل قسم ((T) -> R)? کا اندازہ لگاتا ہے۔ کامپائلر چیک کرتا ہے کہ بادن میں تمام return اظہار مطابق فنکشنل قدرتیں واپس کرتے ہیں۔ کیپچر کیئے گئے متغیر lambda آبجیکٹ میں محفوظ ہوتے ہیں اور جب تک اس کا حوالہ موجود ہے، قابل رسائی رہتے ہیں۔ یہ ایک طاقتور میکانزم ہے، لیکن میمری منیجمنٹ پر توانایی کی ضرورت ہے۔

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { x -> x * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)
    println(double(5))  // 10
    println(triple(5)) // 15
}

makeMultiplier فنکشن ایک factor لیتا ہے اور lambda { x -> x * factor } واپس کرتا ہے، جہاں factor بیرونی دائرہ کار (بندش) سے کیپچر کیا گیا ہے۔ makeMultiplier کا ہر کال اپنی factor قدرت کے ساتھ ایک نیا فنکشن بناتا ہے۔ double اور triple متغیر واپس کیئے گئے فنکشنز کو محفوظ کرتے ہیں اور کائی بار کال کیئے جا سکتے ہیں۔ یہ نمونہ HTTP کلائینٹ ترتیب، ڈیکوریٹرز اور میڈل ویئر میں وسیع پیمانے پر استعمال ہوتا ہے۔

Lambda کے ساتھ higher-order function: مثالیں

Higher-order functions اور lambda کا مشترک استعمال درمیانی متغیروں کے بغیر اظہاری عملیاتی زنجیریں بنانے کی اجازت دیتا ہے۔ Kotlin کی معیاری لائبشری میں درجنوں higher-order functions موجود ہیں: let، run، apply، also، filter، map، flatMap، fold، reduce، forEach، groupBy اور دیگر۔ ہر ایک lambda لیتا ہے اور اس کے ساتھ ڈیٹا تبدیل کرتا ہے۔

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(
        User("Alice", 25),
        User("Bob", 17),
        User("Charlie", 30)
    )

    val result = users
        .filter { it.age >= 18 }
        .map { it.name.uppercase() }
        .sorted()
    println(result) // [ALICE, CHARLIE]
}

مثال میں، تین higher-order functions کی ایک زنجیر صارفین کی فہرست پر کاروائی کرتی ہے۔ filter ایک محمول لیتا ہے، صرف بالغوں کو رکھتا ہے۔ map ہر صارف کو بځے حروف میں نام میں تبدیل کرتا ہے۔ sorted نتیجے کو بڑھتے حروف کے مطابق ترتیب دیتا ہے۔ ہر عمل ایک lambda لیتا ہے، اور Kotlin ہر مرحلہ پر قسم حفاظت کا اہتمام کرتا ہے۔ Higher-order functions کے بغیر، if کے ساتھ ایک لوپ، عارضی فہرستیں اور دستی ترتیب لکھنے پڈت۔۔