IO की Composition
Effects का क्रम निर्धारित करना
IO की Composition, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
flatMap के साथ क्रमबद्ध करना
क्योंकि IO एक monad है, आप प्रभावों को flatMap के साथ संयोजित करते हैं। प्रत्येक चरण क्रम से चलता है और बाद का चरण पहले वाले के परिणाम का उपयोग कर सकता है।
import cats.effect.IO
val program: IO[Unit] =
IO("Alice").flatMap(name => IO.println(s"Hello, $name"))for-comprehension
for-comprehension का रूपांतरण flatMap/map में हो जाता है और यह शुद्ध रहते हुए अनिवार्य स्क्रिप्ट जैसा पढ़ता है।
import cats.effect.IO
val prog: IO[Unit] = for {
_ <- IO.println("What is your name?")
name <- IO("Bob")
_ <- IO.println(s"Hi $name")
} yield ()क्रम सुरक्षित रहता है
for-comprehension में प्रभाव प्रोग्राम के निष्पादन के समय ऊपर से नीचे की ओर चलते हैं। आपके कोड की संरचना निष्पादन क्रम को दर्शाती है।
स्वतंत्र प्रभावों को संयोजित करना
जब दो प्रभाव एक-दूसरे पर निर्भर नहीं होते, तो उन्हें संयोजित करने के लिए mapN या (a, b).tupled का उपयोग करें। वे डिफ़ॉल्ट रूप से क्रमिक रूप से चलते हैं, लेकिन उनकी स्वतंत्रता व्यक्त करते हैं।
import cats.effect.IO
import cats.syntax.apply._
val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)प्रभावों को समानांतर चलाना
स्वतंत्र प्रभावों को अलग-अलग फाइबर पर समवर्ती रूप से चलाने और उनके परिणाम संयोजित करने के लिए parMapN (cats.syntax.parallel से) का उपयोग करें।
import cats.effect.IO
import cats.syntax.parallel._
val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)परिणामों को छोड़ना
किसी प्रभाव को चलाकर दूसरा परिणाम रखने के लिए *> का, या पहला परिणाम रखने के लिए <* का उपयोग करें। void परिणाम को पूरी तरह छोड़ देता है और IO[Unit] उत्पन्न करता है।
import cats.effect.IO
val r1: IO[Int] = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).voidप्रभावों को दोहराना
replicateA(n) किसी प्रभाव को n बार चलाता है और परिणामों को एक सूची में एकत्र करता है। foreverM इसे अनिश्चित काल तक दोहराता है।
import cats.effect.IO
val three: IO[List[Unit]] = IO.println("tick").replicateA(3)List पर Traverse करना
traverse के साथ List[A] को List[B] पर प्रभाव में बदलें। प्रत्येक तत्व एक IO उत्पन्न करता है और परिणाम एकत्र किए जाते हैं।
import cats.effect.IO
import cats.syntax.traverse._
val names = List("a", "b", "c")
val prog: IO[List[Unit]] = names.traverse(n => IO.println(n))parTraverse
parTraverse, traverse का समानांतर संस्करण है — प्रत्येक तत्व का प्रभाव अपने फाइबर पर चलता है। कई URL प्राप्त करने जैसे समवर्ती इनपुट/आउटपुट कार्यों के लिए यह आदर्श है।
import cats.effect.IO
import cats.syntax.parallel._
val ids = List(1, 2, 3)
val prog: IO[List[Int]] = ids.parTraverse(id => IO(id * 10))एक संयोजित प्रोग्राम
यह प्रोग्राम एक मान पढ़ता है, उसे दोगुना करता है और परिणाम प्रिंट करता है — यह सब एक ही विवरण में छोटे IO चरणों से संयोजित होकर होता है।
import cats.effect.{IO, IOApp}
object Doubler extends IOApp.Simple {
def run: IO[Unit] = for {
n <- IO(21)
d = n * 2
_ <- IO.println(s"Doubled: $d")
} yield ()
}साधारण Scala में क्रमबद्ध करना
तुलना के लिए, यहाँ साधारण Scala में क्रमिक कंसोल आउटपुट है — ऊपर दिए गए स्थगित IO संस्करण के विपरीत, यह तुरंत और अशुद्ध रूप से चलता है।
object Main {
def main(args: Array[String]): Unit = {
val n = 21
val d = n * 2
println(s"Doubled: $d")
}
}त्वरित जाँच
कौन-सी विधि दो स्वतंत्र प्रभावों को समवर्ती रूप से चलाकर उनके परिणाम संयोजित करती है?
पुनरावलोकन
आपने इन साधनों के साथ IO प्रोग्राम संयोजित किए:
- क्रमबद्ध करने के लिए
flatMapऔरfor - स्वतंत्र प्रभावों के लिए
mapN/parMapN - संयोजन या परिणाम छोड़ने के लिए
*>,<*,void - संग्रहों के लिए
traverse/parTraverse
अगला भाग: IO के भीतर त्रुटियों को संभालना।
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “IO की Composition” पाठ निःशुल्क है?
हाँ—“IO की Composition” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“IO की Composition” में मैं क्या सीखूँगा?
Effects का क्रम निर्धारित करना आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“IO की Composition” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Cats Type Classes
- IO Monad
- IO की Composition
- IO में Error Handling