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 निर्दिष्ट करना पर्याप्त है। ऐसे फ़ंक्शन को कॉल करते समय, तर्क या तो लैम्ब्डा व्यंजक, या :: के माध्यम से मौजूदा फ़ंक्शन का संदर्भ, या वेरिएबल में संग्रहीत कार्यात्मक मान होता है।

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 के रूप में जोड़ा जाता है।

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

फ़ंक्शन लौटाते समय, 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 फ़ंक्शन एक कारक लेता है और lambda { x -> x * factor } लौटाता है, जहाँ factor बाहरी दायरे (closure) से कैप्चर किया गया है। makeMultiplier का प्रत्येक कॉल अपने स्वयं के factor मान के साथ एक नया फ़ंक्शन बनाता है। चर double और triple लौटाए गए फ़ंक्शन को संग्रहीत करते हैं और कई बार कॉल किए जा सकते हैं। यह पैटर्न HTTP क्लाइंट कॉन्फ़िगरेशन, डेकोरेटर और मिडलवेयर में व्यापक रूप से उपयोग किया जाता है।

लैम्ब्डा के साथ higher-order function: उदाहरण

Higher-order functions और lambdas का संयोजन मध्यवर्ती चर के बिना अभिव्यंजक ऑपरेशन श्रृंखला बनाने की अनुमति देता है। 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 के साथ लूप, अस्थायी सूचियाँ और मैन्युअल सॉर्टिंग लिखनी पड़ती।