Scala Language
उच्च आदेश समारोह

टिप्पणियों

फ़ंक्शन मान के रूप में विधियों का उपयोग करना

स्काला संकलक स्वचालित रूप से उच्च मूल्यों वाले कार्यों में उन्हें पारित करने के उद्देश्य से विधियों को फ़ंक्शन मानों में परिवर्तित करेगा।

object MyObject {
  def mapMethod(input: Int): String = {
    int.toString
  }
}

Seq(1, 2, 3).map(MyObject.mapMethod) // Seq("1", "2", "3")

ऊपर दिए गए उदाहरण में, MyObject.mapMethod एक फ़ंक्शन कॉल नहीं है, लेकिन इसके बजाय मान के रूप में map करने के लिए पास किया गया है। वास्तव में, map को इसके लिए पारित एक फ़ंक्शन मान की आवश्यकता होती है, जैसा कि यह हस्ताक्षर में देखा जा सकता है। List[A] के map के लिए हस्ताक्षर (प्रकार A की वस्तुओं की सूची) है:

def map[B](f: (A) ⇒ B): List[B]

f: (A) => B भाग इंगित करता है कि इस विधि कॉल के लिए पैरामीटर कुछ फ़ंक्शन है जो प्रकार A की वस्तु लेता है और प्रकार B का एक वस्तु लौटाता है। A और B को मनमाने ढंग से परिभाषित किया गया है। पहले उदाहरण पर लौटते हुए, हम देख सकते हैं कि mapMethod एक Int (जो कि A मेल खाती है) लेता है और एक String (जो B मेल खाती है) को लौटाता है। इस प्रकार mapMethod map पास करने के लिए एक वैध फ़ंक्शन मान है। हम इस तरह से एक ही कोड को फिर से लिख सकते हैं:

Seq(1, 2, 3).map(x:Int => int.toString)

यह फ़ंक्शन मान को इनलाइन करता है, जो सरल कार्यों के लिए स्पष्टता जोड़ सकता है।

उच्च आदेश कार्य (पैरामीटर के रूप में कार्य)

एक उच्च-क्रम फ़ंक्शन, पहले-क्रम फ़ंक्शन के विपरीत, तीन रूपों में से एक हो सकता है:

• इसका एक या अधिक पैरामीटर एक फ़ंक्शन है, और यह कुछ मान लौटाता है।

• यह एक फ़ंक्शन देता है, लेकिन इसका कोई भी पैरामीटर एक फ़ंक्शन नहीं है।

• उपरोक्त दोनों: इसका एक या अधिक पैरामीटर एक फ़ंक्शन है, और यह एक फ़ंक्शन देता है।

  object HOF {
      def main(args: Array[String]) {
      val list = List(("Srini","E"),("Subash","R"),("Ranjith","RK"),("Vicky","s"),("Sudhar","s"))
      //HOF
       val fullNameList= list.map(n => getFullName(n._1, n._2))
  
       }
  
      def getFullName(firstName: String, lastName: String): String = firstName + "." + lastName
      }
  

यहाँ मानचित्र फ़ंक्शन एक पैरामीटर के रूप में एक getFullName(n._1,n._2) फ़ंक्शन लेता है। इसे HOF (हायर ऑर्डर फंक्शन) कहा जाता है ।

तर्क आलसी मूल्यांकन

Scala संकेतन का उपयोग करते हुए फ़ंक्शन तर्कों के लिए आलसी मूल्यांकन का समर्थन करता है: def func(arg: => String) । ऐसे फ़ंक्शन तर्क नियमित String ऑब्जेक्ट या उच्च क्रम फ़ंक्शन को String रिटर्न प्रकार के साथ ले सकते हैं। दूसरे मामले में, फ़ंक्शन तर्क का मूल्यांकन मूल्य के उपयोग पर किया जाएगा।

कृपया उदाहरण देखें:

def calculateData: String = {
  print("Calculating expensive data! ")
  "some expensive data"
}

def dumbMediator(preconditions: Boolean, data: String): Option[String] = {
  print("Applying mediator")
  preconditions match {
    case true => Some(data)
    case false => None
  }
}

def smartMediator(preconditions: Boolean, data: => String): Option[String] = {
  print("Applying mediator")
  preconditions match {
    case true => Some(data)
    case false => None
  }
}

smartMediator(preconditions = false, calculateData)

dumbMediator(preconditions = false, calculateData)

smartMediator कॉल कोई भी मान नहीं लौटाएगा और "Applying mediator" संदेश प्रिंट करेगा।

dumbMediator कॉल कोई भी मान नहीं लौटाएगा और संदेश "Calculating expensive data! Applying mediator" ।

जब आप महंगे तर्कों की ओवरहेड का अनुकूलन करना चाहते हैं, तो आलसी मूल्यांकन बेहद उपयोगी हो सकता है।