Kotlin Academy · पाठ

Either<L, R>: Exceptions के बिना Typed Error Handling

अपवाद उत्पन्न किए बिना सफलता और विफलता दर्शाने के लिए Either का उपयोग करें।

पाठ 1, कुल 4 में से13 चरण

Either<L, R>: Exceptions के बिना Typed Error Handling, CoddyKit पर Kotlin Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Kotlin Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

व्यावसायिक तर्क के लिए अपवादों की समस्या

अपवाद अप्रत्याशित विफलताओं के लिए बनाए गए हैं (नल पॉइंटर, IO त्रुटि)। अपेक्षित व्यावसायिक विफलताओं (सत्यापन विफलता, “नहीं मिला”) का संकेत देने के लिए इनका उपयोग करने से नियंत्रण प्रवाह अदृश्य हो जाता है, हर कॉल करने वाली जगह पर अपवाद पकड़ने पड़ते हैं और फ़ंक्शन हस्ताक्षरों में त्रुटियाँ छिप जाती हैं।

Either<L, R> क्या है

Either दो मामलों वाला योग प्रकार है: Left(value: L) में सामान्यतः त्रुटि होती है और Right(value: R) में सामान्यतः सफलता का मान होता है। Either लौटाने वाला फ़ंक्शन अपने हस्ताक्षर में विफलता की संभावना स्पष्ट करता है।

Arrow का Either

Either और उसके ऑपरेटरों का पूरा पारिस्थितिकी तंत्र पाने के लिए अपने प्रोजेक्ट में Arrow जोड़ें:

// build.gradle.kts
implementation("io.arrow-kt:arrow-core:1.2.4")

// Usage
import arrow.core.Either
import arrow.core.left
import arrow.core.right

फ़ंक्शन से Either लौटाना

सफलता के लिए value.right() और विफलता के लिए error.left() लौटाएँ। कॉल करने वाले को दोनों शाखाओं को संभालना होगा:

sealed class UserError { object NotFound : UserError(); data class InvalidEmail(val msg: String) : UserError() }

fun findUser(id: Long): Either<UserError, User> =
    if (id <= 0) UserError.NotFound.left()
    else User(id, "Alice").right()

fold से Either के दोनों मामले संभालना

दोनों मामलों को एक ही एक्सप्रेशन में संभालने के लिए fold(ifLeft, ifRight) का उपयोग करें:

val result = findUser(1L)
val message = result.fold(
    ifLeft  = { error -> "Error: $error" },
    ifRight = { user  -> "Found: ${user.name}" }
)
println(message)

map से Right मान बदलना

map { }, Left को छुए बिना Right मान में रूपांतरण करता है। इससे Either एक फ़ंक्टर बनता है — आप रूपांतरणों को सुरक्षित रूप से शृंखला में जोड़ सकते हैं:

val nameResult: Either<UserError, String> = findUser(1L).map { it.name }

flatMap के साथ शृंखला बनाना

flatMap { } ऐसे संगणनों को शृंखला में जोड़ता है जो स्वयं Either लौटाते हैं। यदि कोई चरण Left लौटाता है, तो शृंखला तुरंत रुक जाती है और बाद के चरणों को चलाए बिना त्रुटि आगे पहुँच जाती है:

fun validateEmail(email: String): Either<UserError, String> =
    if (email.contains("@")) email.right()
    else UserError.InvalidEmail("bad format").left()

fun createUser(email: String): Either<UserError, User> =
    validateEmail(email).flatMap { validEmail ->
        User(1L, validEmail).right()
    }

अपवादों को लपेटने के लिए Either.catch

Either.catch { } एक ब्लॉक चलाता है और किसी भी अपवाद को Left के रूप में लपेटता है। इसे ऐसे पुराने कोड और आपके Either-आधारित डोमेन के बीच की सीमा पर उपयोग करें, जो अपवाद उत्पन्न करता है:

val result: Either<Throwable, User> = Either.catch {
    userRepository.findOrThrow(id)
}

getOrElse और orElse से पुनर्प्राप्ति

getOrElse { default } Right मान निकालता है या डिफ़ॉल्ट मान लौटाता है। orElse { alternativeEither } किसी Left को दूसरी गणना से बदल देता है:

val user: User = findUser(0L).getOrElse { User(-1L, "Guest") }
val user2: Either<UserError, User> = findUser(0L).orElse { User(99L, "Default").right() }

when के साथ पैटर्न मिलान

सीलबंद Either-जैसी क्लास पर when का उपयोग करें, या is Either.Left / Either.Right के साथ स्वयं Either पर इसका उपयोग करके सभी मामलों को पूरी तरह संभालें:

when (val r = findUser(1L)) {
    is Either.Left  -> println("Error: ${r.value}")
    is Either.Right -> println("User: ${r.value.name}")
}

सेवा परतों में Either

रिपॉज़िटरी और सेवा फ़ंक्शन से Either लौटाएँ। व्यावसायिक तर्क को फ़्रेमवर्क संबंधी चिंताओं से मुक्त रखते हुए, Ktor रूट स्तर पर इसे HTTP प्रतिक्रियाओं में बदलें:

get("/users/{id}") {
    val id = call.parameters["id"]?.toLongOrNull() ?: return@get call.respond(HttpStatusCode.BadRequest)
    userService.findById(id).fold(
        ifLeft  = { call.respond(HttpStatusCode.NotFound) },
        ifRight = { call.respond(it) }
    )
}

त्वरित जाँच

Either.Left मान पर flatMap { } क्या करता है?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: Either<L, R>

मुख्य बातें:

Either फ़ंक्शन हस्ताक्षर में विफलता का मार्ग स्पष्ट करता है
Right = सफलता; Left = विफलता (परंपरा के अनुसार)
map { } — सफलता के मान में रूपांतरण करें; flatMap { } — विफल हो सकने वाली गणनाओं को शृंखला में जोड़ें
fold(ifLeft, ifRight) — दोनों मामलों को एक ही एक्सप्रेशन में उपयोग करें
Either.catch { } — अपवाद उत्पन्न करने वाले कोड को सीमाओं पर लपेटें

शुरुआत निःशुल्क

एआई शिक्षक के साथ Kotlin सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 51
पाठ: 203

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Either<L, R>: Exceptions के बिना Typed Error Handling” पाठ निःशुल्क है?

हाँ — Kotlin Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “Either<L, R>: Exceptions के बिना Typed Error Handling” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Either<L, R>: Exceptions के बिना Typed Error Handling” में मैं क्या सीखूँगा?

अपवाद उत्पन्न किए बिना सफलता और विफलता दर्शाने के लिए Either का उपयोग करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Kotlin Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Kotlin Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Kotlin Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“Either<L, R>: Exceptions के बिना Typed Error Handling” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Kotlin Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Kotlin Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

Either : Exceptions के बिना Typed Error Handling
Arrow Raise DSL: टाइपयुक्त त्रुटियों का संयोजन
Option और Nullable: प्रत्येक का उपयोग कब करें
Arrow के मुख्य प्रकारों से कार्यात्मक डोमेन मॉडलिंग

← Kotlin Academy पर वापस जाएँ