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

कोटलिन में कार्यात्मक प्रोग्रामिंग का परिचय

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

शुद्ध फ़ंक्शन और अपरिवर्तनीयता

शुद्ध फ़ंक्शन क्या है?

शुद्ध फ़ंक्शन वह फ़ंक्शन है जो:

• समान आर्गुमेंट के लिए हमेशा एक ही परिणाम लौटाता है (नियतात्मकता)।
• इसका कोई साइड इफ़ेक्ट नहीं होता (बाहरी स्थिति नहीं बदलता, ग्लोबल वेरिएबल नहीं पढ़ता, इनपुट/आउटपुट नहीं करता)।

शुद्ध फ़ंक्शन का उदाहरण:

fun sum(a: Int, b: Int): Int = a + b

अशुद्ध फ़ंक्शन का उदाहरण (बाहरी स्थिति पर निर्भर):

var counter = 0fun impureSum(a: Int, b: Int): Int {    counter++ // साइड इफ़ेक्ट    return a + b}

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

FP में डेटा बनाने के बाद उसे बदलने से बचा जाता है। Kotlin में इसके लिए उपयोग किया जाता है:

• अपरिवर्तनीय रेफरेंस घोषित करने के लिए var के बजाय val।
• अपरिवर्तनीय कलेक्शन: listOf, mapOf, setOf।
• data-क्लास के लिए copy() के माध्यम से बदलावों के साथ ऑब्जेक्ट की प्रतिलिपि बनाना।

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

fun main() {    val user = User("Alice", 25)    val updatedUser = user.copy(age = 26) // नई प्रतिलिपि बनाते हैं    println(user)        // User(name=Alice, age=25)    println(updatedUser) // User(name=Alice, age=26)}

अपरिवर्तनीयता के लाभ: डीबगिंग सरल, थ्रेड-सुरक्षित, कोड पूर्वानुमानित।

उच्च-क्रम फ़ंक्शन और लैम्ब्डा एक्सप्रेशन

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

Kotlin में फ़ंक्शन को आर्गुमेंट के रूप में पास किया जा सकता है, अन्य फ़ंक्शन से लौटाया जा सकता है और वेरिएबल में संग्रहीत किया जा सकता है। यह कार्यात्मक शैली का आधार है।

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

fun main() {    val sum = operateOnNumbers(5, 3) { x, y -> x + y }    val product = operateOnNumbers(5, 3) { x, y -> x * y }    println("योग: $sum, गुणनफल: $product")}

लैम्ब्डा एक्सप्रेशन

लैम्ब्डा एक अनाम फ़ंक्शन है जो संक्षिप्त रूप में लिखा जाता है। सिंटैक्स: { आर्गुमेंट -> बॉडी }।

val square: (Int) -> Int = { x -> x * x }val result = square(4) // 16

// यदि केवल एक आर्गुमेंट है, तो अंतर्निहित नाम it का उपयोग किया जा सकता हैval double: (Int) -> Int = { it * 2 }

अंतर्निहित उच्च-क्रम फ़ंक्शन

Kotlin कलेक्शन के साथ काम करने के लिए कई उपयोगी फ़ंक्शन प्रदान करता है:

• map — प्रत्येक तत्व को रूपांतरित करता है।
• filter — शर्त को पूरा करने वाले तत्वों को रखता है।
• fold — प्रारंभिक एक्युमुलेटर के साथ कलेक्शन को एक मान में समेटता है।

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

    // map: वर्ग करना    val squares = numbers.map { it * it }    println(squares) // [1, 4, 9, 16, 25]

    // filter: केवल सम संख्याएँ रखना    val evens = numbers.filter { it % 2 == 0 }    println(evens) // [2, 4]

    // fold: सभी तत्वों का योग    val sum = numbers.fold(0) { acc, element -> acc + element }    println(sum) // 15

    // श्रृंखला कॉल: सम वर्ग    val evenSquares = numbers        .filter { it % 2 == 0 }        .map { it * it }    println(evenSquares) // [4, 16]}