Kotlin में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

Kotlin में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

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

1. फ़ंक्शन कम्पोज़ीशन और करीइंग

कम्पोज़ीशन दो या अधिक फ़ंक्शनों को क्रमिक रूप से लागू करके एक नया फ़ंक्शन बनाना है। Kotlin में Haskell की तरह कोई अंतर्निहित कम्पोज़ीशन ऑपरेटर नहीं है, लेकिन इसे extension-फ़ंक्शन के माध्यम से आसानी से लागू किया जा सकता है।

फ़ंक्शन कम्पोज़ीशन का उदाहरण

// फ़ंक्शन परिभाषित करेंval double: (Int) -> Int = { it * 2 }val increment: (Int) -> Int = { it + 1 }

// कम्पोज़ीशन: पहले double, फिर incrementinfix fun <A, B, C> ((B) -> C).compose(f: (A) -> B): (A) -> C = { a -> this(f(a)) }

val doubleThenIncrement = increment compose doubleprintln(doubleThenIncrement(5)) // 11 (5*2 + 1)

करीइंग (Currying)

करीइंग कई आर्गुमेंट वाले फ़ंक्शन को एक-एक आर्गुमेंट वाले फ़ंक्शनों की श्रृंखला में बदलना है। Kotlin में इसे नेस्टेड लैम्ब्डा के साथ लागू किया जाता है।

// सामान्य फ़ंक्शनfun sum(a: Int, b: Int): Int = a + b

// करीड संस्करणfun curriedSum(a: Int): (Int) -> Int = { b -> a + b }

val add5 = curriedSum(5)println(add5(3)) // 8

// करीइंग के लिए सार्वभौमिक फ़ंक्शनfun <A, B, C> ((A, B) -> C).curry(): (A) -> (B) -> C = { a -> { b -> this(a, b) } }

val curriedSum2 = ::sum.curry()println(curriedSum2(10)(20)) // 30

करीइंग विशेष रूप से आंशिक अनुप्रयोग और फ़ंक्शन फ़ैक्टरी के साथ काम करते समय उपयोगी है।

2. फंक्टर और मोनाड: व्यवहार में सिद्धांत

फंक्टर एक कंटेनर है जिसे किसी फ़ंक्शन का उपयोग करके मैप (map) किया जा सकता है। मोनाड एक फंक्टर है जिसमें कंटेनरों को संयोजित करने की क्षमता होती है (flatMap)। Kotlin में मोनाड का एक प्रमुख उदाहरण Result (या Either) है, साथ ही Sequence भी है।

Result के साथ उदाहरण (Either मोनाड)

data class User(val name: String, val email: String)

fun parseUser(json: String): Result<User> = runCatching {    // पार्सिंग का अनुकरण    if (json.isBlank()) throw IllegalArgumentException("खाली JSON")    User("Alice", "alice@example.com")}

fun sendEmail(user: User): Result<String> = runCatching {    if (user.email.contains("@")) "ईमेल ${user.email} पर भेजा गया"    else throw IllegalArgumentException("अमान्य ईमेल")}

// मोनैडिक श्रृंखलाval result = parseUser("{...}")    .flatMap { user -> sendEmail(user) }    .map { message -> "सफलता: $message" }    .onFailure { error -> println("त्रुटि: ${error.message}") }

println(result.getOrDefault("विफल"))

यहाँ flatMap सफलता/त्रुटि की नेस्टेड जाँचों से बचाता है, जिससे कोड रैखिक और पढ़ने योग्य हो जाता है।

अपना फंक्टर बनाना: Option प्रकार

sealed class Option<out T> {    data class Some<T>(val value: T) : Option<T>()    object None : Option<Nothing>()}

fun <T, R> Option<T>.map(f: (T) -> R): Option<R> = when (this) {    is Option.Some -> Option.Some(f(value))    is Option.None -> Option.None}

fun <T, R> Option<T>.flatMap(f: (T) -> Option<R>): Option<R> = when (this) {    is Option.Some -> f(value)    is Option.None -> Option.None}

val maybeNumber: Option<Int> = Option.Some(42)val resultOption = maybeNumber    .map { it * 2 }    .flatMap { Option.Some("मान: $it") }

println(resultOption) // Some(value=मान: 84)