Either की Composition
map और flatMap
Either की Composition, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
Computations को compose करना
वास्तविक programs कई ऐसे steps को chain करते हैं जो विफल हो सकते हैं: parse, validate, lookup, compute। Either आपको इन्हें compose करने देता है, ताकि पहली failure पूरी chain को short-circuit कर दे।
इसके tools हैं map, flatMap और for-comprehensions।
flatMap Eithers को क्रम में चलाता है
flatMap ऐसा function लागू करता है जो स्वयं एक Either लौटाता है। यदि receiver Left है, तो function कभी call नहीं होता और Left आगे propagate हो जाता है।
object Main {
def positive(n: Int): Either[String, Int] =
if (n > 0) Right(n) else Left("not positive")
def main(args: Array[String]): Unit = {
val r = Right(5).flatMap(positive)
val l = Right(-1).flatMap(positive)
println(r)
println(l)
}
}Short-circuiting
जब आप कई flatMap calls को chain करते हैं, तो पहला Left सब कुछ रोक देता है। बाद के steps छोड़ दिए जाते हैं और वही error अंतिम result बन जाता है।
object Main {
def step(label: String, n: Int): Either[String, Int] = {
println(s"running $label")
Right(n + 1)
}
def main(args: Array[String]): Unit = {
val result = Left("early error").asInstanceOf[Either[String, Int]]
.flatMap(n => step("A", n))
.flatMap(n => step("B", n))
println(result)
}
}Either पर for-comprehension
क्योंकि Either right-biased है, इसलिए आप इसका उपयोग for-comprehension में कर सकते हैं। प्रत्येक <- एक Right को unwrap करता है; कोई भी Left comprehension को रोककर result बन जाता है।
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val sum = for {
a <- parse("3")
b <- parse("4")
} yield a + b
println(sum)
}
}विफल for-comprehension
यदि comprehension का कोई भी step Left देता है, तो पूरा expression वही Left होता है और बाद के steps नहीं चलते।
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val sum = for {
a <- parse("3")
b <- parse("oops")
c <- parse("5")
} yield a + b + c
println(sum)
}
}Validations को chain करना
एक वास्तविक pipeline: string को parse करें, फिर business rule जाँचें और उसके बाद transform करें। प्रत्येक stage एक Either लौटाता है।
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight("not a number")
def checkRange(n: Int): Either[String, Int] =
if (n >= 1 && n <= 100) Right(n) else Left("out of range")
def process(s: String): Either[String, Int] =
parse(s).flatMap(checkRange).map(_ * 10)
def main(args: Array[String]): Unit = {
println(process("7"))
println(process("500"))
println(process("x"))
}
}map बनाम flatMap
जब आपका function plain value लौटाता है, तब map का उपयोग करें। जब वह दूसरा Either लौटाता है, तब flatMap का उपयोग करें, ताकि nested Either[String, Either[String, Int]] न बने।
@main def run(): Unit = {
val withMap: Either[String, Int] = Right(2).map(_ + 1)
val nested: Either[String, Either[String, Int]] = Right(2).map(n => Right(n + 1))
val flat: Either[String, Int] = Right(2).flatMap(n => Right(n + 1))
println(withMap)
println(nested)
println(flat)
}स्वतंत्र values को combine करना
जब प्रत्येक step पिछले step पर निर्भर न हो, तब भी for-comprehension काम करता है। अंतिम yield के चलने के लिए सभी steps का सफल होना आवश्यक है।
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val combined = for {
x <- parse("10")
y <- parse("20")
z <- parse("30")
} yield List(x, y, z).sum
println(combined)
}
}leftMap-शैली में error transformation
Standard library के Either में leftMap नहीं है, लेकिन आप swap.map(...).swap से या fold के अंदर mapping करके error को transform कर सकते हैं। इससे pipeline में error types एकसमान रहते हैं।
@main def run(): Unit = {
val e: Either[String, Int] = Left("low-level error")
val mapped = e.swap.map(msg => s"context: $msg").swap
println(mapped)
}सब कुछ एक साथ लागू करना
एक छोटी calculator pipeline जो दो numbers को parse करके divide करती है और किसी भी failure को typed error के रूप में report करती है।
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad number: $s")
def divide(a: Int, b: Int): Either[String, Int] =
if (b == 0) Left("division by zero") else Right(a / b)
def calc(x: String, y: String): Either[String, Int] =
for {
a <- parse(x)
b <- parse(y)
r <- divide(a, b)
} yield r
def main(args: Array[String]): Unit = {
println(calc("20", "4"))
println(calc("20", "0"))
println(calc("x", "4"))
}
}यह महत्वपूर्ण क्यों है
Either को compose करने से आपको railway-oriented programming मिलता है: happy path Right से होकर आगे बढ़ता है और कोई भी error Left track पर मुड़कर बाकी steps को bypass कर देता है। न exceptions, न null checks—सिर्फ values।
त्वरित जाँच
Either को compose करने की अपनी समझ जाँचें।
पुनरावलोकन
आपने Either को compose करना सीखा:
flatMapविफल हो सकने वाले steps को क्रम में चलाता है और पहलेLeftपर short-circuit करता है।- कई steps वाली pipelines के लिए
for-comprehensions साफ़ और सुगम होती हैं। - Plain results के लिए
mapऔर Either लौटाने वाले functions के लिएflatMapका उपयोग करें। swap.map(...).swapसे errors को transform करें।
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “Either की Composition” पाठ निःशुल्क है?
हाँ—“Either की Composition” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Either की Composition” में मैं क्या सीखूँगा?
map और flatMap आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“Either की Composition” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Errors के लिए Either
- Try, Success, Failure
- Either की Composition
- Types के बीच Conversion