Scala Language
टाइप पैरामीटर (जेनरिक)

विकल्प का प्रकार

पैरामीटर प्रकार का एक अच्छा उदाहरण विकल्प प्रकार है । यह मूल रूप से केवल निम्नलिखित परिभाषा है (प्रकार पर परिभाषित कई और तरीकों के साथ):

sealed abstract class Option[+A] {
  def isEmpty: Boolean
  def get: A

  final def fold[B](ifEmpty: => B)(f: A => B): B =
    if (isEmpty) ifEmpty else f(this.get)

  // lots of methods...
}

case class Some[A](value: A) extends Option[A] {
  def isEmpty = false
  def get = value
}

case object None extends Option[Nothing] {
  def isEmpty = true
  def get = throw new NoSuchElementException("None.get")
}

हम यह भी देख सकते हैं कि इसमें एक पैरामीटर विधि है, fold , जो टाइप B का कुछ लौटाता है।

व्यास वाले तरीके

एक विधि का वापसी प्रकार पैरामीटर के प्रकार पर निर्भर कर सकता है। इस उदाहरण में, x पैरामीटर है, A प्रकार का x , जिसे टाइप पैरामीटर के रूप में जाना जाता है।

def f[A](x: A): A = x

f(1)         // 1
f("two")     // "two"
f[Float](3)  // 3.0F

स्काला रिटर्न प्रकार को निर्धारित करने के लिए टाइप इनफैक्शन का उपयोग करेगा, जो कसौटी पर कसता है कि किन तरीकों को बुलाया जा सकता है। इस प्रकार, देखभाल की जानी चाहिए: निम्नलिखित एक संकलन-समय की त्रुटि है क्योंकि * हर प्रकार A लिए परिभाषित नहीं है:

def g[A](x: A): A = 2 * x  // Won't compile

सामान्य संग्रह

Ints की सूची को परिभाषित करना

trait IntList { ... }

class Cons(val head: Int, val tail: IntList) extends IntList { ... }

class Nil extends IntList { ... }

लेकिन क्या होगा अगर हमें बूलियन, डबल आदि की सूची को परिभाषित करने की आवश्यकता है?

जेनेरिक सूची को परिभाषित करना

trait List[T] {
  def isEmpty: Boolean
  def head: T
  def tail: List[T]
}

class Cons[T](val head: [T], val tail: List[T]) extends List[T] {
  def isEmpty: Boolean = false
}

class Nil[T] extends List[T] {
  def isEmpty: Boolean = true

  def head: Nothing = throw NoSuchElementException("Nil.head")

  def tail: Nothing = throw NoSuchElementException("Nil.tail")
}