Scala Language
आंशिक कार्य

रचना

आंशिक फ़ंक्शन का उपयोग अक्सर भागों में कुल फ़ंक्शन को परिभाषित करने के लिए किया जाता है:

sealed trait SuperType
case object A extends SuperType
case object B extends SuperType
case object C extends SuperType

val pfA: PartialFunction[SuperType, Int] = {
  case A => 5
}

val pfB: PartialFunction[SuperType, Int] = {
  case B => 10
}

val input: Seq[SuperType] = Seq(A, B, C)

input.map(pfA orElse pfB orElse {
  case _ => 15
}) // Seq(5, 10, 15)

इस उपयोग में, आंशिक क्रियाओं को orElse विधि के साथ संयोजन के क्रम में करने का प्रयास किया जाता है। आमतौर पर, एक अंतिम आंशिक फ़ंक्शन प्रदान किया जाता है जो सभी शेष मामलों से मेल खाता है। सामूहिक रूप से, इन कार्यों का संयोजन कुल फ़ंक्शन के रूप में कार्य करता है।

यह पैटर्न आम तौर पर उन चिंताओं को अलग करने के लिए उपयोग किया जाता है जहां एक फ़ंक्शन प्रभावी रूप से कोड कोड के लिए एक डिस्पैचर का कार्य कर सकता है। यह आम है, उदाहरण के लिए, एक अक्का अभिनेता की प्राप्त विधि में ।

`संग्रह` के साथ उपयोग

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

उदाहरण 1

यह मानते हुए कि हमारे पास एक वर्गमूल फ़ंक्शन आंशिक फ़ंक्शन के रूप में परिभाषित है:

val sqRoot:PartialFunction[Double,Double] = { case n if n > 0 => math.sqrt(n) }

हम साथ यह आह्वान कर सकते हैं collect Combinator:

List(-1.1,2.2,3.3,0).collect(sqRoot)

प्रभावी रूप से एक ही ऑपरेशन के रूप में प्रदर्शन:

List(-1.1,2.2,3.3,0).filter(sqRoot.isDefinedAt).map(sqRoot)

उदाहरण 2

sealed trait SuperType // `sealed` modifier allows inheritance within current build-unit only
case class A(value: Int) extends SuperType
case class B(text: String) extends SuperType
case object C extends SuperType

val input: Seq[SuperType] = Seq(A(5), B("hello"), C, A(25), B(""))

input.collect {
  case A(value) if value < 10   => value.toString
  case B(text) if text.nonEmpty => text
} // Seq("5", "hello")

उपरोक्त उदाहरण में ध्यान देने योग्य कई बातें हैं:

• प्रत्येक पैटर्न मैच के बाईं ओर प्रभावी रूप से तत्वों को संसाधित करने और आउटपुट में शामिल करने के लिए चयन करता है। कोई भी मान जिसके मिलान का case नहीं है, वह केवल छोड़ा गया है।
• दाईं ओर वाला पक्ष केस-विशिष्ट प्रसंस्करण को लागू करने के लिए परिभाषित करता है।
• पैटर्न मिलान गार्ड स्टेटमेंट ( if क्लॉस) और राइट-हैंड साइड में उपयोग के लिए चर को बांधता है।

मूल वाक्य रचना

स्कैला में एक विशेष प्रकार का फ़ंक्शन होता है जिसे एक आंशिक फ़ंक्शन कहा जाता है, जो सामान्य कार्यों का विस्तार करता है - जिसका अर्थ है कि एक PartialFunction Function1 का उपयोग किया जा सकता है जहां Function1 की अपेक्षा की जाती है। आंशिक कार्यों को गुमनाम रूप से पैटर्न मिलान में उपयोग किए गए case सिंटैक्स का उपयोग करके परिभाषित किया जा सकता है:

val pf: PartialFunction[Boolean, Int] = {
  case true => 7
}

pf.isDefinedAt(true) // returns true
pf(true) // returns 7

pf.isDefinedAt(false) // returns false
pf(false) // throws scala.MatchError: false (of class java.lang.Boolean)

जैसा कि उदाहरण में देखा गया है, एक आंशिक फ़ंक्शन को इसके पहले पैरामीटर के पूरे डोमेन पर परिभाषित करने की आवश्यकता नहीं है। एक मानक Function1 उदाहरण को कुल माना जाता है, जिसका अर्थ है कि यह हर संभव तर्क के लिए परिभाषित किया गया है।

कुल फ़ंक्शन के रूप में उपयोग

मुहावरेदार स्काला में आंशिक कार्य बहुत आम हैं। वे अक्सर अपने सुविधाजनक case आधारित सिंटैक्स के लिए उपयोग किया जाता है ताकि लक्षणों पर कुल कार्यों को परिभाषित किया जा सके:

sealed trait SuperType // `sealed` modifier allows inheritance within current build-unit only
case object A extends SuperType
case object B extends SuperType
case object C extends SuperType

val input: Seq[SuperType] = Seq(A, B, C)

input.map {
  case A => 5
  case _ => 10
} // Seq(5, 10, 10)

यह एक नियमित अनाम फ़ंक्शन में match स्टेटमेंट के अतिरिक्त सिंटैक्स को बचाता है। की तुलना करें:

input.map { item => 
  item match {
    case A => 5
    case _ => 10
  }
} // Seq(5, 10, 10)

यह भी अक्सर पैटर्न मिलान का उपयोग करते हुए एक पैरामीटर अपघटन करने के लिए उपयोग किया जाता है, जब एक कार्य करने के लिए एक ट्यूपल या एक केस क्लास पास किया जाता है:

val input = Seq("A" -> 1, "B" -> 2, "C" -> 3)

input.map { case (a, i) =>
   a + i.toString
} // Seq("A1", "B2", "C3")

मानचित्र फ़ंक्शन में टुपल्स निकालने के लिए उपयोग

ये तीन मैप फ़ंक्शंस समतुल्य हैं, इसलिए उस विविधता का उपयोग करें जो आपकी टीम को सबसे अधिक पठनीय लगती है।

val numberNames = Map(1 -> "One", 2 -> "Two", 3 -> "Three")

// 1. No extraction
numberNames.map(it => s"${it._1} is written ${it._2}" )

// 2. Extraction within a normal function
numberNames.map(it => {
    val (number, name) = it
    s"$number is written $name"
})

// 3. Extraction via a partial function (note the brackets in the parentheses)
numberNames.map({ case (number, name) => s"$number is written $name" })

आंशिक फ़ंक्शन को सभी इनपुट से मेल खाना चाहिए : जो भी मामला मेल नहीं खाता है वह रनटाइम पर एक अपवाद फेंक देगा।