Lambda: یہ کیا ہے، نحو اور Kotlin میں استعمال

Lambda کیا ہے؟

Lambda (lambda اظہار) ایک گمنام فنکشن ہے جو اعلان کے بجائے ایک اظہار کے طور پر بیان کیا جاتا ہے۔ یہ اصطلاح ایلونزو چرچ کے lambda حساب (1936) سے ماخوذ ہے۔ پروگرامنگ میں، lambda کوڈ کا ایک بلاک ہے جسے قدر کے طور پر منتقل کیا جا سکتا ہے، متغیر میں محفوظ کیا جا سکتا ہے اور بعد میں بلایا جا سکتا ہے۔ Kotlin میں، lambda ہمیشہ گھنگریالے قوسین { } میں گھرا ہوتا ہے، جس میں آرگومنٹس -> تیر کے ذریعے باڈی سے الگ کیے جاتے ہیں۔

Lambda ایک عام فنکشن سے نام اور fun کلیدی لفظ کی عدم موجودگی میں مختلف ہوتا ہے۔ یہ اضافی اعلانات کے ساتھ کوڈ کو بے ترتیب کیے بغیر استعمال کے مقام پر براہ راست رویہ اعلان کرنے کی اجازت دیتا ہے۔ Kotlin مرتب کنندہ سیاق و سباق سے آرگومنٹ کی اقسام کا اندازہ لگاتا ہے، لہٰذا بہت سے معاملات میں اقسام کو چھوڑا جا سکتا ہے۔ Lambda فعالی قسم (T) -> R پر نحوی شوگر ہے: ہر lambda کی ایک مطابقت پذیر فعالی قسم ہوتی ہے۔

Kotlin میں lambdas کا بنیادی استعمال انہیں اعلیٰ ترتیب کے فنکشنز میں منتقل کرنا ہے۔ معیاری لائبریری ہر جگہ lambdas استعمال کرتی ہے: filter { it > 0 }، map { it.uppercase() }، forEach { println(it) }۔ Lambdas ایونٹ سننے والوں، کال بیکس اور apply اور run کے ذریعے آبجیکٹ کنفیگریٹرز کے لیے بھی استعمال ہوتے ہیں، جو گمنام کلاسز کے مقابلے میں کوڈ کو زیادہ اعلانیہ بناتے ہیں۔

Kotlin میں lambda اظہارات کا نحو

Kotlin میں lambda اظہار کی مکمل شکل: { آرگومنٹس -> lambda_باڈی }۔ آرگومنٹس کو کوما سے الگ کرکے درج کیا جاتا ہے، اس کے بعد ایک تیر اور باڈی — ایک یا زیادہ اظہارات۔ اگر باڈی میں کئی سطور ہوں تو آخری اظہار واپسی کی قدر بن جاتا ہے۔ اگر کوئی فنکشن lambda کو آخری آرگومنٹ کے طور پر لیتا ہے، تو اسے کال قوسین کے باہر منتقل کیا جا سکتا ہے۔

val sum: (Int, Int) -> Int = { a, b -> a + b }

// سیاق و سباق سے اندازہ کردہ اقسام
val sumShort = { a: Int, b: Int -> a + b }

// Lambda کال
val result = sum(5, 3)  // 8
println(result)

متغیر sum ایک واضح فعالی قسم (Int, Int) -> Int کے ساتھ اعلان کیا گیا ہے اور ایک lambda { a, b -> a + b } سے شروع کیا گیا ہے۔ sumShort کے لیے، اقسام lambda کے اندر متعین ہیں اور متغیر کی قسم کا اندازہ لگایا گیا ہے۔ دونوں شکلیں مساوی ہیں۔ lambda کو بلانا ایک عام فنکشن کو بلانے سے مختلف نہیں — sum(5, 3) نحو استعمال کرتے ہوئے۔ بغیر آرگومنٹ کے lambda کو { body } لکھا جاتا ہے، ایک آرگومنٹ کے ساتھ — { it -> it * 2 } یا صرف { it * 2 }۔

مضمر it اور آرگومنٹس کا ترک کرنا

جب lambda بالکل ایک آرگومنٹ لیتا ہے، Kotlin مضمر نام it فراہم کرتا ہے۔ یہ بائیں جانب آرگومنٹ اعلان کرنے کی ضرورت کو ختم کرتا ہے۔ ڈویلپر صرف lambda باڈی لکھتا ہے، واحد پیرامیٹر تک رسائی کے لیے it استعمال کرتا ہے۔ یہ نحو خاص طور پر کلیکشن پروسیسنگ چینز میں آسان ہے، جہاں it موجودہ عنصر کی طرف اشارہ کرتا ہے۔

val numbers = listOf(1, 2, 3, 4, 5)

// واضح پیرامیٹر نام
val squaredExplicit = numbers.map { n -> n * n }

// مضمر it
val squared = numbers.map { it * it }

// it کے ساتھ فلٹرنگ
val even = numbers.filter { it % 2 == 0 }

println(squared) // [1, 4, 9, 16, 25]

مثال میں، map { it * it } n -> اعلان کرنے کے بجائے it استعمال کرتا ہے۔ Kotlin خود بخود ایک lambda پیرامیٹر کے لیے it تفویض کرتا ہے۔ اگر lambda دو یا زیادہ آرگومنٹ لیتا ہے، it نہیں بنایا جاتا — تمام پیرامیٹرز کو واضح طور پر اعلان کرنا ضروری ہے۔ نیسٹڈ lambdas کی بہتر پڑھنے کی اہلیت کے لیے، پیرامیٹرز کو معنی خیز نام دینا اور it کو صرف مختصر ایک سطری پیش گوئوں میں استعمال کرنا مناسب ہے۔

Trailing lambda اور کثیر السطور lambdas

Trailing lambda Kotlin کی ایک نحوی خصوصیت ہے جو آخری lambda آرگومنٹ کو فنکشن کال قوسین کے باہر منتقل کرنے کی اجازت دیتی ہے۔ یہ کوڈ کو بلٹ ان لینگویج کنسٹرکٹس سے مشابہ بناتا ہے۔ اگر lambda واحد آرگومنٹ ہے، قوسین کو مکمل طور پر چھوڑا جا سکتا ہے۔ یہ نقطہ نظر معیاری لائبریری اور DSLs میں فعال طور پر استعمال ہوتا ہے۔

// معیاری کال
thread(block = {
    println("تھریڈ سے ہیلو")
})

// Trailing lambda ورژن
thread {
    println("تھریڈ سے ہیلو")
}

// trailing lambda کے ساتھ دہرائیں
repeat(3) { index ->
    println("تکرار $index")
}

// کثیر السطور lambda کے ساتھ چلائیں
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

thread فنکشن آخری آرگومنٹ کے طور پر Runnable قبول کرتا ہے۔ trailing lambda کی بدولت، lambda کو قوسین کے باہر منتقل کیا جا سکتا ہے، جو بصری طور پر کوڈ بلاک جیسا لگتا ہے۔ repeat فنکشن تکرار کی تعداد اور ایک انڈیکس کے ساتھ lambda لیتا ہے۔ run ایک اعلیٰ ترتیب کے فنکشن کی مثال ہے جہاں کثیر السطور lambda آخری اظہار کے ذریعے واپس کردہ قدر کا حساب لگاتا ہے۔ run() کے ارد گرد کے قوسین کو چھوڑا جا سکتا ہے اگر lambda واحد آرگومنٹ ہو۔

lambdas میں متغیر کی گرفت (closure)

متغیر کی گرفت (closure) lambda کی بیرونی دائرہ کار میں اعلان کردہ متغیرات تک رسائی حاصل کرنے کی صلاحیت ہے۔ Kotlin میں، lambda var متغیرات کو پڑھ اور تبدیل کر سکتا ہے، نیز ارد گرد کے سیاق و سباق سے val متغیرات پڑھ سکتا ہے۔ گرفت کیے گئے متغیرات اپنی پوری زندگی کے دوران lambda کے ساتھ محفوظ رہتے ہیں، جو حالت والے فنکشنز بنانے کے قابل بناتے ہیں۔

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // گرفت کی تعداد
    }
}

fun main() {
    val counter = makeCounter()
    println(counter()) // 0
    println(counter()) // 1
    println(counter()) // 2
}

makeCounter فنکشن ایک مقامی متغیر count کا اعلان کرتا ہے اور ایک lambda { count++ } واپس کرتا ہے۔ اگرچہ makeCounter نے عملدرآمد مکمل کر لیا ہے، واپس کیا گیا lambda بندش کے ذریعے count کا حوالہ برقرار رکھتا ہے۔ counter() کی ہر کال موجودہ قدر میں اضافہ کرتی ہے اور اسے واپس کرتی ہے۔ بندش کا طریقہ کار کریئنگ، فنکشن فیکٹریز اور میموائزیشن کی بنیاد ہے۔ یہ یاد رکھنا ضروری ہے کہ قابل تبدیلی متغیرات کو پکڑنا متوازی عملدرآمد میں غیر متوقع رویے کا سبب بن سکتا ہے۔