बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

Cats Type Classes

Functor, Monad आदि

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

Cats Type Classes, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

टाइप क्लास क्या हैं

टाइप क्लास, तदर्थ बहुरूपता का एक पैटर्न है। यह आपको किसी प्रकार को संशोधित किए बिना उसमें व्यवहार जोड़ने देता है। Cats एक Scala लाइब्रेरी है जो कार्यात्मक प्रोग्रामिंग के लिए टाइप क्लास का समृद्ध पदानुक्रम उपलब्ध कराती है।

Functor — ऐसी चीज़ें जिन पर आप map कर सकते हैं
Applicative — स्वतंत्र प्रभावों को संयोजित करता है
Monad — निर्भर प्रभावों का क्रम निर्धारित करता है

फ़ंक्टर: map

एक Functor[F] map प्रदान करता है। यह संदर्भ की संरचना बदले बिना, उसके भीतर के मान को बदलता है।

import cats.Functor
import cats.instances.option._

val f = Functor[Option].map(Some(2))(_ + 1)
println(f) // Some(3)

Functor के नियम

एक नियम-सम्मत Functor को दो नियमों का पालन करना चाहिए:

पहचान: fa.map(x => x) == fa
संयोजन: fa.map(f).map(g) == fa.map(f.andThen(g))

इन गारंटियों से आप map की शृंखलाओं का सुरक्षित रूप से पुनर्गठन कर सकते हैं।

Applicative: pure और ap

Applicative[F], Functor का विस्तार करता है और pure (किसी मान को संदर्भ में उठाना) तथा mapN के साथ स्वतंत्र मानों को संयोजित करने की क्षमता जोड़ता है।

import cats.Applicative
import cats.instances.option._

val lifted = Applicative[Option].pure(42)
println(lifted) // Some(42)

mapN के साथ संयोजन

mapN का सिंटैक्स कई स्वतंत्र प्रभावयुक्त मानों को एक में संयोजित करता है और सभी मान उपलब्ध होने पर एक फ़ंक्शन लागू करता है।

import cats.syntax.apply._
import cats.instances.option._

val result = (Option(1), Option(2), Option(3)).mapN(_ + _ + _)
println(result) // Some(6)

Monad: flatMap

Monad[F], Applicative का विस्तार करता है और flatMap जोड़ता है, जो निर्भर गणनाओं को क्रमबद्ध करता है। प्रत्येक चरण पिछले चरण के परिणाम पर निर्भर कर सकता है।

import cats.Monad
import cats.instances.option._

val m = Monad[Option].flatMap(Some(3))(x => Some(x * 10))
println(m) // Some(30)

Monad के नियम

Monads को तीन नियमों का पालन करना चाहिए:

बाईं पहचान: pure(a).flatMap(f) == f(a)
दाईं पहचान: m.flatMap(pure) == m
सहचारीता: नेस्ट किए गए flatMaps को अलग-अलग समूहों में रखा जा सकता है

Semigroup और Monoid

एक Semigroup[A] combine को परिभाषित करता है (जो सहचारी होता है)। एक Monoid[A] इसमें empty पहचान तत्व जोड़ता है। ये फोल्डिंग और संचयन का आधार हैं।

import cats.syntax.semigroup._
import cats.instances.int._
import cats.instances.string._

println(3 |+| 4)       // 7
println("foo" |+| "bar") // foobar

Foldable

Foldable[F] किसी संरचना पर फोल्डिंग को अमूर्त करता है। Monoid के साथ मिलकर, combineAll किसी संग्रह को एकल मान में घटा देता है।

import cats.Foldable
import cats.instances.list._
import cats.instances.int._

val total = Foldable[List].combineAll(List(1, 2, 3, 4))
println(total) // 10

Traverse

Traverse[F] आपको प्रत्येक तत्व को किसी प्रभाव में मैप करने और परिणाम एकत्र करने देता है; इस तरह List[F[A]] को F[List[A]] में बदला जाता है।

import cats.syntax.traverse._
import cats.instances.list._
import cats.instances.option._

val r = List(1, 2, 3).traverse(x => Option(x * 2))
println(r) // Some(List(2, 4, 6))

टाइप क्लास महत्वपूर्ण क्यों हैं

टाइप क्लास आपको ऐसा कोड लिखने देते हैं जो आवश्यक व्यवहार प्रदान करने वाले किसी भी प्रकार के साथ काम करता है। Monad[F] द्वारा सीमित फ़ंक्शन Option, List, IO और अन्य प्रकारों के साथ काम करता है — एक बार लिखिए और हर जगह पुनः उपयोग कीजिए।

import cats.Monad
import cats.syntax.flatMap._
import cats.syntax.functor._

def twice[F[_]: Monad, A](fa: F[A])(f: A => A): F[A] =
  fa.flatMap(a => Monad[F].pure(f(f(a))))

त्वरित जाँच

कौन-सी टाइप क्लास निर्भर गणनाओं को क्रमबद्ध करने के लिए flatMap जोड़ती है?

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

पुनरावलोकन

आपने मुख्य Cats टाइप क्लास पदानुक्रम का अध्ययन किया:

Functor — map
Applicative — pure और mapN
Monad — flatMap
Semigroup/Monoid — combine/empty
Foldable/Traverse — प्रभावों को फोल्ड और एकत्र करना

अगले भाग में आप प्रभावों को शुद्ध रूप से मॉडल करने वाले IO monad से परिचित होंगे।

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

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

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

पाठ्यक्रम: 39
पाठ: 143

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

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

क्या “Cats Type Classes” पाठ निःशुल्क है?

हाँ—“Cats Type Classes” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Cats Type Classes” में मैं क्या सीखूँगा?

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

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

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

“Cats Type Classes” पाठ पूरा करने में कितना समय लगता है?

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

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

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

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

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ