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

Type Class Pattern

Ad-hoc polymorphism

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

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

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

टाइप क्लास प्रकारों में बिना उन्हें बदले व्यवहार जोड़ने का एक पैटर्न है। यह एड-हॉक बहुरूपता का एक रूप है: एक ही संक्रिया कई असंबंधित प्रकारों पर काम करती है और कंपाइलर इसे प्रकार के आधार पर चुनता है।

यह Haskell से आया है और Cats जैसी Scala लाइब्रेरी में व्यापक रूप से उपयोग होता है।

यह जिस समस्या का समाधान करता है

विरासत किसी प्रकार की परिभाषा के समय ही उसके भीतर व्यवहार निर्धारित कर देती है। लेकिन अक्सर आप किसी प्रकार को संपादित नहीं कर सकते (क्योंकि वह किसी लाइब्रेरी में होता है), या आप अलग-अलग संदर्भों में अलग व्यवहार चाहते हैं। टाइप क्लास आपको व्यवहार बाहरी रूप से जोड़ने देती हैं।

चरण 1: Trait परिभाषित करें

टाइप क्लास एक प्रकार से पैरामीटर किया गया trait होता है। यहाँ Show[A] यह बताता है कि किसी भी A को String के रूप में कैसे प्रस्तुत करना है।

trait Show[A] {
  def show(value: A): String
}

@main def run(): Unit = {
  println("Show trait defined")
}

चरण 2: Instances उपलब्ध कराएं

हर उस ठोस प्रकार के लिए, जिसका आप समर्थन करना चाहते हैं, trait का एक instance बनाएं। इन्हें टाइप क्लास instances कहा जाता है।

trait Show[A] { def show(value: A): String }

object Main {
  val intShow: Show[Int] = (v: Int) => s"Int($v)"
  val strShow: Show[String] = (v: String) => s"Str($v)"

  def main(args: Array[String]): Unit = {
    println(intShow.show(7))
    println(strShow.show("hi"))
  }
}

चरण 3: Instance का उपयोग करें

एक फ़ंक्शन instance को पैरामीटर के रूप में लेता है। वही render फ़ंक्शन ऐसे किसी भी प्रकार के लिए काम करता है, जिसके पास Show instance हो।

trait Show[A] { def show(value: A): String }

object Main {
  def render[A](value: A, s: Show[A]): String = s.show(value)

  val intShow: Show[Int] = (v: Int) => s"<$v>"

  def main(args: Array[String]): Unit = {
    println(render(99, intShow))
  }
}

इसे Implicit बनाना

Instances को हाथ से पास करना उबाऊ होता है। Instance और पैरामीटर को implicit चिह्नित करने पर (या Scala 3 में using लिखने पर) कंपाइलर उसे अपने-आप उपलब्ध करा देता है।

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"<$v>"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(42))
  }
}

एड-हॉक बहुरूपता

तर्क के प्रकार के आधार पर एक ही फ़ंक्शन नाम अलग-अलग कार्यान्वयनों को चुनता है। इसे एड-हॉक बहुरूपता कहते हैं। यह उपप्रकार बहुरूपता (विरासत) और पैरामीट्रिक बहुरूपता (जेनेरिक) से अलग है।

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"int:$v"
  implicit val boolShow: Show[Boolean] = (v: Boolean) => s"bool:$v"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(5))
    println(render(true))
  }
}

कस्टम प्रकारों के साथ काम करना

इसकी वास्तविक शक्ति यह है कि आप अपने प्रकारों में साफ़-सुथरे ढंग से व्यवहार जोड़ सकते हैं और डेटा क्लास को फ़ॉर्मैटिंग संबंधी चिंताओं से मुक्त रख सकते हैं।

trait Show[A] { def show(value: A): String }

case class User(name: String, age: Int)

object Main {
  implicit val userShow: Show[User] = (u: User) => s"${u.name} (${u.age})"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(User("Ada", 36)))
  }
}

टाइप क्लास बनाम इंटरफ़ेस

इंटरफ़ेस व्यवहार को प्रकार की परिभाषा से जोड़ता है, जबकि टाइप क्लास दोनों को अलग रखती है।

आप ऐसे प्रकार के लिए टाइप क्लास instance जोड़ सकते हैं, जिसका स्वामित्व आपके पास नहीं है।
अलग-अलग संदर्भों के लिए आपके पास कई instances हो सकते हैं।
कॉल किए जाने के स्थान पर कंपाइलर व्यवहार चुनता है।

तीन घटक

हर टाइप क्लास के तीन भाग होते हैं:

trait (अमूर्त संक्रिया)।
instances (हर प्रकार के लिए कार्यान्वयन)।
interface (ऐसे फ़ंक्शन जिन्हें instance की आवश्यकता होती है)।

अगले पाठों में आप प्रत्येक भाग का अध्ययन करेंगे।

एक पूर्ण छोटा उदाहरण

Implicit instance का उपयोग करने वाले जेनेरिक फ़ंक्शन के माध्यम से इस पैटर्न को एक साथ समझें।

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"#$v"
  implicit val strShow: Show[String] = (v: String) => '"' + v + '"'

  def printAll[A](xs: List[A])(implicit s: Show[A]): Unit =
    xs.foreach(x => println(s.show(x)))

  def main(args: Array[String]): Unit = {
    printAll(List(1, 2, 3))
    printAll(List("a", "b"))
  }
}

त्वरित जाँच

टाइप क्लास पैटर्न की अपनी समझ जाँचें।

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

पुनरावलोकन

आपने टाइप क्लास पैटर्न सीखा:

पैरामीटर किया गया trait किसी संक्रिया का वर्णन करता है।
Instances हर प्रकार के लिए उसका कार्यान्वयन करते हैं।
implicit पैरामीटर कंपाइलर को instance उपलब्ध कराने देते हैं।
इससे एड-हॉक बहुरूपता मिलती है और आप ऐसे प्रकारों का विस्तार कर सकते हैं, जिनका स्वामित्व आपके पास नहीं है।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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