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 एकमात्र आर्गुमेंट है, कोष्ठक पूरी तरह से छोड़े जा सकते हैं। यह दृष्टिकोण मानक पुस्तकालय और DSL में सक्रिय रूप से उपयोग किया जाता है।

// मानक कॉल
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() का प्रत्येक कॉल वर्तमान मान को बढ़ाता और लौटाता है। क्लोज़र तंत्र करीइंग, फ़ंक्शन फ़ैक्टरी और मेमोइज़ेशन का आधार है। यह याद रखना महत्वपूर्ण है कि परिवर्तनशील वेरिएबल्स को कैप्चर करना समवर्ती निष्पादन में अप्रत्याशित व्यवहार का कारण बन सकता है।