Kotlin में कार्यात्मक प्रोग्रामिंग: मूल बातें और उदाहरण

Kotlin पर कार्यात्मक प्रोग्रामिंग का परिचय

Kotlin एक आधुनिक मल्टी-पैराडाइम भाषा है जो ऑब्जेक्ट-ओरिएंटेड और कार्यात्मक प्रोग्रामिंग को सहजता से जोड़ती है। संक्षिप्त सिंटैक्स और शक्तिशाली क्षमताओं के कारण, Kotlin आपको स्वच्छ, पूर्वानुमानित और आसानी से परीक्षण योग्य कोड लिखने की अनुमति देता है। Kotlin में कार्यात्मक प्रोग्रामिंग (FP) केवल एक फैशनेबल चलन नहीं है, बल्कि रोजमर्रा के कार्यों को हल करने के लिए एक शक्तिशाली उपकरण है: संग्रह प्रसंस्करण से लेकर एसिंक्रोनस कॉल चेन बनाने तक।

इस लेख में, हम Kotlin पर लागू FP की प्रमुख अवधारणाओं पर चर्चा करेंगे: डेटा अपरिवर्तनीयता, प्रथम श्रेणी के मान के रूप में फ़ंक्शन, लैम्ब्डा व्यंजक, उच्च-क्रम फ़ंक्शन और संग्रह प्रसंस्करण श्रृंखलाएँ (map, filter, reduce)। सभी उदाहरण व्यावहारिक कोड के साथ होंगे जिन्हें आप तुरंत IntelliJ IDEA या ऑनलाइन कंपाइलर में चला सकते हैं।

Kotlin में कार्यात्मक दृष्टिकोण की मूल बातें

अपरिवर्तनीयता (Immutability)

FP का मूलभूत सिद्धांत अपरिवर्तनीय डेटा के साथ काम करना है। Kotlin में इसके लिए कीवर्ड val (अपरिवर्तनीय संदर्भ) और अपरिवर्तनीय संग्रह (listOf, mapOf, setOf) का उपयोग किया जाता है।

// अपरिवर्तनीय सूचीval numbers: List<Int> = listOf(1, 2, 3, 4, 5)

// बदलने का प्रयास संकलन त्रुटि देगा// numbers.add(6) // त्रुटि!

// उत्परिवर्तन के बजाय नया संग्रह बनाएँval newNumbers = numbers + 6 // [1, 2, 3, 4, 5, 6]

अपरिवर्तनीयता के लाभ स्पष्ट हैं: कोड थ्रेड-सुरक्षित हो जाता है, डीबग करना आसान होता है, और साइड इफेक्ट कम से कम होते हैं। यदि आपको डेटा बदलने की आवश्यकता है, तो आप हमेशा आवश्यक परिवर्तनों के साथ एक नई प्रतिलिपि बनाते हैं।

प्रथम श्रेणी के मान के रूप में फ़ंक्शन

Kotlin में, फ़ंक्शन पूर्ण वस्तुएँ हैं। उन्हें चरों को सौंपा जा सकता है, अन्य फ़ंक्शनों में पास किया जा सकता है, और फ़ंक्शनों से वापस किया जा सकता है। फ़ंक्शन का प्रकार कोष्ठक में तीर के साथ लिखा जाता है:

// मान के रूप में फ़ंक्शनval sum: (Int, Int) -> Int = { a, b -> a + b }

// उपयोगval result = sum(10, 20) // 30

// फ़ंक्शन जो दूसरे फ़ंक्शन को स्वीकार करता हैfun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {    return operation(a, b)}

println(operate(5, 3, sum)) // 8println(operate(5, 3, { x, y -> x * y })) // 15

ध्यान दें: यदि लैम्ब्डा अंतिम तर्क है, तो Kotlin इसे कोष्ठक के बाहर रखने की अनुमति देता है - इसे trailing lambda सिंटैक्स कहा जाता है, जो कोड को बहुत पठनीय बनाता है।

लैम्ब्डा व्यंजक और उच्च-क्रम फ़ंक्शन

लैम्ब्डा व्यंजक

लैम्ब्डा एक अनाम फ़ंक्शन है जो घुंघराले ब्रेसिज़ में संलग्न होता है। Kotlin में, लैम्ब्डा बाहरी संदर्भ (क्लोजर) से चर कैप्चर कर सकते हैं।

// सरल लैम्ब्डाval greet = { name: String -> "नमस्ते, $name!" }println(greet("अन्ना")) // नमस्ते, अन्ना!

// कई मापदंडों के साथ लैम्ब्डाval multiply: (Int, Int) -> Int = { a, b -> a * b }

// यदि एक पैरामीटर है, तो it का उपयोग किया जा सकता हैval double = { it: Int -> it * 2 }println(double(5)) // 10

उच्च-क्रम फ़ंक्शन (Higher-Order Functions)

ये ऐसे फ़ंक्शन हैं जो अन्य फ़ंक्शनों को तर्क के रूप में स्वीकार करते हैं या उन्हें वापस करते हैं। Kotlin की मानक लाइब्रेरी में ऐसे कई फ़ंक्शन हैं: let, apply, run, with और अन्य। आइए एक व्यावहारिक उदाहरण देखें:

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

fun processUsers(users: List<User>, filter: (User) -> Boolean, transform: (User) -> String): List<String> {    return users.filter(filter).map(transform)}

val users = listOf(    User("इवान", 25),    User("मारिया", 17),    User("पीटर", 30))

// वयस्कों को फ़िल्टर करें और उनके नाम प्रदर्शित करेंval adultNames = processUsers(    users,    filter = { it.age >= 18 },    transform = { "वयस्क: ${it.name}" })