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

Currying

Partial application

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

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

करी बनाना क्या है?

करी बनाना कई तर्कों वाली फ़ंक्शन को फ़ंक्शन की ऐसी शृंखला में बदलता है, जिनमें से प्रत्येक एक तर्क लेती है। Scala में इसे कई पैरामीटर सूचियों के साथ लिखा जाता है।

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    println(add(3)(4))
  }
}

कई पैरामीटर सूचियाँ

करी की गई विधि में कई पैरामीटर सूचियाँ होती हैं: def f(a: Int)(b: Int)। आप प्रत्येक सूची को क्रम से देकर इसे कॉल करते हैं: f(1)(2)।

object Main {
  def combine(prefix: String)(value: Int): String = s"$prefix$value"
  def main(args: Array[String]): Unit = {
    println(combine("id-")(42))
  }
}

आंशिक अनुप्रयोग

आप केवल कुछ तर्क सूचियाँ लागू करके बाकी की प्रतीक्षा करने वाली फ़ंक्शन प्राप्त कर सकते हैं। इसे आंशिक अनुप्रयोग कहा जाता है।

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    val addFive = add(5) _
    println(addFive(10))
    println(addFive(20))
  }
}

सामान्य फ़ंक्शन को विशिष्ट बनाना

आंशिक अनुप्रयोग से आप सामान्य फ़ंक्शन से विशिष्ट फ़ंक्शन बना सकते हैं और दोहराव कम कर सकते हैं।

object Main {
  def power(exp: Int)(base: Int): Int = math.pow(base, exp).toInt
  def main(args: Array[String]): Unit = {
    val square = power(2) _
    val cube = power(3) _
    println(square(5))
    println(cube(2))
  }
}

सामान्य फ़ंक्शन को करी करना

सामान्य फ़ंक्शन मान में एक .curried विधि होती है, जो उसे करी किए गए रूप में बदल देती है।

object Main {
  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val curriedAdd = add.curried
    println(curriedAdd(3)(4))
  }
}

वापस सामान्य रूप में बदलना

Function.uncurried सहायक इस प्रक्रिया को उलटता है और करी की गई फ़ंक्शन को एकल पैरामीटर सूची वाली फ़ंक्शन में बदल देता है।

object Main {
  def main(args: Array[String]): Unit = {
    val curried: Int => Int => Int = a => b => a + b
    val normal = Function.uncurried(curried)
    println(normal(3, 4))
  }
}

करी बनाने की उपयोगिता

करी बनाना पुनः उपयोग को सक्षम करता है: पहले तर्कों को एक बार निश्चित करें, फिर अलग-अलग शेष तर्कों के साथ परिणाम को कई बार कॉल करें। यह बाद की सूचियों में कंपाइलर को प्रकारों का अनुमान लगाने में भी सहायता करता है।

object Main {
  def discount(rate: Double)(price: Double): Double = price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val blackFriday = discount(0.3) _
    println(blackFriday(100))
    println(blackFriday(250))
  }
}

अंतिम सूची में प्रकार का अनुमान

कई पैरामीटर सूचियों का एक व्यावहारिक लाभ यह है कि कंपाइलर पहले की सूचियों से लैम्ब्डा के पैरामीटर प्रकारों का अनुमान लगा सकता है, इसलिए आप उन्हें छोड़ सकते हैं।

object Main {
  def fold[A](xs: List[A])(init: A)(op: (A, A) => A): A =
    xs.foldLeft(init)(op)
  def main(args: Array[String]): Unit = {
    val total = fold(List(1, 2, 3))(0)((a, b) => a + b)
    println(total)
  }
}

तीन सूचियों के साथ करी बनाना

आप जितनी चाहें उतनी पैरामीटर सूचियाँ रख सकते हैं। प्रत्येक कॉल एक सूची देती है और अगली सूची के लिए एक फ़ंक्शन लौटाती है।

object Main {
  def make(a: Int)(b: Int)(c: Int): Int = a + b + c
  def main(args: Array[String]): Unit = {
    println(make(1)(2)(3))
    val step = make(10) _
    println(step(20)(30))
  }
}

विन्यास योग्य सत्यापनकर्ता बनाना

एक सामान्य वास्तविक उपयोग यह है: सत्यापन नियम को करी करें, सीमा निश्चित करें और परिणामी शर्त-फ़ंक्शन का डेटा-समुच्चय पर पुनः उपयोग करें।

object Main {
  def atLeast(min: Int)(value: Int): Boolean = value >= min
  def main(args: Array[String]): Unit = {
    val adult = atLeast(18) _
    println(List(15, 21, 18, 12).map(adult))
  }
}

करी बनाना बनाम आंशिक अनुप्रयोग

करी बनाना एक-तर्क वाली फ़ंक्शन में किया जाने वाला संरचनात्मक रूपांतरण है। आंशिक अनुप्रयोग अभी कुछ तर्क देने और बाकी बाद में देने की क्रिया है। करी की गई फ़ंक्शन आंशिक अनुप्रयोग को स्वाभाविक बनाती हैं।

object Main {
  def greet(greeting: String)(name: String): String = s"$greeting, $name!"
  def main(args: Array[String]): Unit = {
    val sayHi = greet("Hi") _
    println(sayHi("Ann"))
    println(sayHi("Bob"))
  }
}

त्वरित जाँच

Scala में करी की गई विधि कैसे परिभाषित करते हैं?

पुनरावलोकन

आपने करी बनाना और आंशिक अनुप्रयोग सीखा:

  • करी की गई विधियाँ कई पैरामीटर सूचियों का उपयोग करती हैं: f(a)(b)
  • नई फ़ंक्शन पाने के लिए f(x) _ से आंशिक रूप से लागू करें
  • .curried और Function.uncurried रूपों को बदलते हैं
  • यह पुनः उपयोग, विशिष्टीकरण और प्रकार-अनुमान में सहायता करता है
शुरुआत निःशुल्क

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. Functions को Values की तरह उपयोग करना
  2. Currying
  3. Composition
  4. Closures
← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ