स्काला के लिए मामला

प्रोग्रामिंग भाषाएं डेवलपर्स के लिए स्क्रूड्राइवर की तरह हैं। एक आकार सभी के लिए उपयुक्त नहीं होता, इसलिए अच्छे प्रोग्रामर अपने टूल बेल्ट में कई आकार रखते हैं। समस्या यह है कि हर समय नई भाषाएँ सामने आ रही हैं और आपके पास उन्हें सीखने के लिए आपके पास और आपके शेड्यूल में केवल इतनी ही जगह है। आज के अतिथि स्तम्भ में, भाषा गुरु डेविड बिसैक इसका पक्ष रखते हैं स्काला, एक नई भाषा जो ऑब्जेक्ट ओरिएंटेड और कार्यात्मक प्रोग्रामिंग भाषाओं से सर्वोत्तम विचार लेती है। के सदस्य के रूप में जेएसआर 201 समिति, डेविड ने जावा 5 में नई सिंटैक्स सुविधाओं को डिजाइन करने में मदद की। वह जावा भाषा विशिष्टता (तीसरा संस्करण), संक्षेप में जावा, आदि के समीक्षक भी थे स्काला में प्रोग्रामिंग. --ईडी

जावा पिछले दर्जनों वर्षों में अच्छी तरह से परिपक्व हो गया है। इसका मतलब केवल यह है कि जावा डेवलपर्स इसकी कमियों से परिचित हैं, जैसे कि जेनेरिक की वाचालता प्रकार की घोषणाएँ, इंटरफ़ेस जो डिफ़ॉल्ट विधि कार्यान्वयन को परिभाषित नहीं कर सकते, इसके बंद होने की कमी, वगैरह। पिछड़ी संगतता इसे मौलिक रूप से विकसित होने से रोकती है, और अन्य गतिशील/स्क्रिप्टिंग भाषाओं की तरह रूबी, ग्रूवी, पायथन अपने उपयोग में आसानी और लचीलेपन के कारण बड़ी संख्या में अनुयायी आकर्षित कर रहे हैं क्षमताएं। इस माहौल में, ( www.scala-lang.org) मार्टिन ओडरस्की ने स्काला को एक ऐसी भाषा के रूप में बनाया, जो जावा के लिए वही करती है जो कई जावा ने सी के लिए किया था: पुरानी भाषा को आगे बढ़ाना (अन्य भाषाओं की महान विशेषताओं के साथ) और इसके कठोर अंशों को अलग करना। हालाँकि, जैसे जावा C नहीं था, वैसे ही स्काला नई सुविधाओं वाला जावा नहीं है। एक पूरी तरह से नई OO भाषा जो JVM पर चलती है और जावा 5 के साथ आसानी से एकीकृत होती है, स्काला भी इसे जोड़कर चीजों को उत्तेजित करती है:

• कार्यात्मक प्रोग्रामिंग. स्काला में फ़ंक्शंस प्रथम श्रेणी ऑब्जेक्ट हैं - उन्हें पैरामीटर के रूप में पारित किया जा सकता है, वेरिएबल्स में संग्रहीत किया जा सकता है, और अन्य फ़ंक्शंस बना और वापस कर सकते हैं। स्काला किसी ऑब्जेक्ट की विधि को फ़ंक्शन में बदलना भी आसान बनाता है (नीचे उदाहरण देखें);
• अनुमान प्रकार, जो आपको कई प्रकार की टिप्पणियों को छोड़ने की अनुमति देता है। स्काला कोड में अक्सर स्क्रिप्टिंग भाषाओं का स्वरूप और अनुभव होता है;
• लक्षण, जो इंटरफेस का वर्णन करता है लेकिन जिसमें कार्यान्वयन के तरीके भी शामिल हो सकते हैं;
• एक अधिक सुसंगत प्रकार की प्रणाली, जिसमें जावा की कुछ सामान्य प्रकार की खामियों का समाधान भी शामिल है। उदाहरण के लिए, Arrayरेत Lists दोनों सामान्य उपप्रकार हैं Seq प्रवृत्ति;
• लचीले पैकेज और आयात, आयातित सुविधाओं का नाम बदलने की क्षमता सहित;
• केस कक्षाएं जो धारक/संरचना वर्गों और सुविधाजनक कंस्ट्रक्टरों के आवश्यक बॉयलरप्लेट को लागू करते हैं, लेकिन शक्तिशाली ऑब्जेक्ट पैटर्न मिलान भी प्रदान करते हैं;
• ऑपरेटरों को विधियों और एक लचीली विधि मंगलाचरण वाक्यविन्यास के साथ प्रतिस्थापित करता है: ऑपरेशन ए + बी वास्तव में फ़ंक्शन कॉल ए + (बी) है। हालाँकि, स्काला कंपाइलर ऐसे कई ऑपरेशनों को एकल जावा बाइटकोड में अनुकूलित करता है;
• XML के लिए प्रत्यक्ष भाषा समर्थन (ग्रूवी के समान);

और कई अन्य सामान्य भाषा "इच्छा सूची" सुविधाएँ, पहले से ही सुसंगत और साफ तरीके से लागू की गई हैं।

स्काला पाने के लिए, डाउनलोड करना आपके सिस्टम के लिए संस्करण (2.7.2-फ़ाइनल वर्तमान स्थिर रिलीज़ है), फिर जोड़ें <scala>/bin अपने लिए PATH. पर्यावरण चर JAVA_HOME को आपके सिस्टम पर स्थापित जावा रनटाइम वातावरण को भी इंगित करना चाहिए। स्काला टूलसेट में शामिल हैं scalac (संकलक), fsc (एक रेजिडेंट कंपाइलर जो धीमी स्टार्टअप लागत से बचाता है), और scala, स्काला रनटाइम। एक्लिप्स, IntelliJ IDEA और NetBeans के लिए प्लगइन्स के साथ-साथ Emacs के लिए संपादन और दुभाषिया मोड भी हैं।

यहां तक ​​कि ग्रूवियर भी

के लिए विकिपीडिया पृष्ठ ग्रूवी दिखाता है कि स्ट्रिंग की सूची को कैसे फ़िल्टर किया जाए, केवल 4 या उससे कम वर्णों को प्रिंट किया जाए:

// Groovy: ["Rod", "Carlos", "Chris"].findAll{it.size()<= 4}. each{println it}

"रॉड" को चुनने और प्रिंट करने के लिए स्काला कोड समान है:

// Scala: List("Rod","Carlos", "Chris").filter{_.length <= 4}. foreach{println}

filter पर एक विधि है Seq टाइप करो List का विस्तार Seq) जो एक फ़ंक्शन स्वीकार करता है। यह फ़ंक्शन लागू होता है length तर्क के लिए विधि (यहाँ इसके साथ दर्शाया गया है _ के बजाय यह) और उसकी तुलना 4 से करता है। filter विधि दूसरी लौटाती है Seq और यह foreach उस पर विधि Seq लागू करता है println इसके भीतर प्रत्येक मान पर कार्य करें। स्काला प्रणाली में शामिल है a पढ़ें, eval, प्रिंट लूप दुभाषिया जो स्काला प्रणाली में चीजों को आज़माने का एक त्वरित, इंटरैक्टिव तरीका है। कंसोल से, बस चलाएँ scala मुख्य वर्ग निर्दिष्ट किए बिना, और परिभाषाएँ और अभिव्यक्तियाँ दर्ज करें:

$ scala. scala> val r = 1 to 11. r: Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
scala> println((r foldLeft 0) {_ + _})
66. scala> println((r foldLeft 1) {_ * _})
39916800

1 से 11, 1 से 11 तक पूर्णांकों की श्रेणी का मूल्यांकन करता है। इजहार (r foldLeft 0) {_ + _} रेंज पर लेफ्ट फोल्ड ऑपरेशन करता है, इसे 0 से सीड करता है और एक अनाम लगाता है शाब्दिक कार्य, {_ + _}, जो दो मान जोड़ता है। यह अभिव्यक्ति गणना करती है (...(((0 + 1) + 2) + 3)... + 11). तीसरी अभिव्यक्ति 1 के बीज का उपयोग करके मानों को गुणा करती है। आप भी उपयोग कर सकते हैं scala स्काला में लिखी गई स्क्रिप्ट को चलाने के लिए। उपरोक्त तीन कथनों को फ़ोल्ड्स.स्कैला में रखें और स्क्रिप्ट चलाएँ:

# scala folds.scala. 66. 39916800

प्रकार, अनुमान लगाया गया

स्काला के प्रकार का अनुमान यहां काम कर रहा है। स्काला के प्रकार का अनुमान लगाता है सूची("रॉड", "कार्लोस", "क्रिस") पहले उदाहरण में प्रकार के साथ स्ट्रिंग्स की एक सूची होनी चाहिए List[String]. इस प्रकार, का परिणाम filter विधि एक है Seq[String] (स्ट्रिंग्स का एक क्रम जिसमें सूची होना आवश्यक नहीं है; सूची Seq तक फैली हुई है)। इसके अलावा, विधेय फ़ंक्शन के प्रकार का अनुमान लगाया जाता है String) => Boolean (अर्थात, यह एक ऐसा फ़ंक्शन है जो एकल को स्वीकार करता है String पैरामीटर और रिटर्न ए Boolean.) द foreach विधि a पर कार्य करती है Seq[String] और इसलिए किसी अन्य फ़ंक्शन प्रकार को स्वीकार करता है, (String) => Unit. (Unit के समान है void प्रकार।) इस प्रकार, जबकि ग्रूवी गतिशील प्रकारों (और इसलिए रनटाइम प्रकार की जांच) का उपयोग करता है, स्काला उपयोग करता है संकलन-समय ने मजबूत टाइपिंग को लागू किया, जिसके परिणामस्वरूप स्क्रिप्ट जैसी बनाए रखते हुए बेहतर प्रदर्शन हुआ शैली।

FLEXIBILITY

स्काला के सिंटैक्स का लचीलापन सीधे स्काला में डोमेन विशिष्ट भाषाओं के निर्माण की अनुमति देता है। उदाहरण के लिए, स्काला का कॉम्बिनेटर पार्सिंग व्याकरणों की अभिव्यक्ति की अनुमति देता है जो उल्लेखनीय रूप से दिखते हैं ईबीएनएफ सीधे स्काला में, भाषा में बिल्कुल भी बदलाव किए बिना - यह सब कार्यात्मक संरचना और अच्छी तरह से चुने गए ऑपरेटरों के साथ किया जाता है। बड़े पैमाने पर, स्काला पैकेज और प्रोग्राम तत्व दृश्यता के सूक्ष्म नियंत्रण का समर्थन करता है। कुशल जावा बाइटकोड का संकलन, जावा इंटरऑपरेबिलिटी के साथ मिलकर, इसे एंटरप्राइज़ कंप्यूटिंग के लिए उपयुक्त बनाता है।

HQ9+, व्याख्या की गई

यहां स्काला का एक लंबा उदाहरण दिया गया है: गूढ़ विद्याओं के लिए एक दुभाषिया HQ9+ भाषा क्लिफ बिफले द्वारा आविष्कार किया गया। HQ9+ एक ऐसी भाषा है जिसमें कुछ सामान्य प्रोग्रामिंग भाषा कार्यों को सबसे संक्षिप्त रूप से कोडित किया जाता है:

1. कथन 'H' प्रिंट करता है "हैलो, दुनिया!" (बुनियादी कंसोल आउटपुट प्रदर्शित करता है)
2. कथन '9' गीत को प्रिंट करता है बीयर की 99 बोतलें (यह या तो बीयर का जश्न मनाता है, या सप्ताह के दिन के आधार पर लूप प्रदर्शित करता है)
3. 'क्यू' स्वयं क्विन का प्रदर्शन करता है (यहाँ कुछ भी अनुचित नहीं है; ए क्विन एक प्रोग्राम है जो अपना स्वयं का स्रोत प्रिंट कर सकता है)
4. '+' रजिस्टर को बढ़ाता है (प्रोग्राम को कुछ गणित करना पड़ता है, है ना? HQ9+ एक संख्यात्मक रजिस्टर को बढ़ा सकता है, लेकिन इसे प्रिंट नहीं कर सकता। याद रखें, हमने कहा था कि HQ9+ एक गूढ़ भाषा है! स्रोत में टिप्पणियाँ दिखाती हैं कि रजिस्टर मान मुद्रित करने के लिए नए कथन कैसे जोड़ें।)

H9Q+ दुभाषिया का एक क्षमाशील स्काला कार्यान्वयन इस प्रकार है।

object HQ9Plus extends Application {
case class Env(program: String, register: Int) // runtime env. type Instruction = Env => Env // function of Env to Env. type Statement = Char. val interpreter = Map[Statement, Instruction](
'H'->{(env: Env) => println("Hello, world!"); env}, 'Q'->{(env: Env) => println(env.program); env}, '+'->{(env: Env) => Env(env.program, env.register + 1)}, // '?'->{println(env.register);env}, // extend language! '9'->{(env: Env) =>
def printn(n: int, s: String) =
if (n == 1) println("1 Bottle of beer" + s)
else println(n + " Bottles of beer" + s)
for (n 
interpreter.get(st.toUpperCase) match {
case Some(instruction) => instruction(env)
case None => env. }
}
override def main(args: Array[String]) {// process cmd line. args.foreach{prog: String => interpret(prog, Env(prog, 0)) }
}
}

HQ9+ इंटरपरेटर को निम्नानुसार संकलित और चलाएँ:

 scalac HQ9Plus.scala # compile the program
scala HQ9Plus H H+H+H? HQ9+ # run three different HQ9+ programs

यह सबसे सरल कार्यान्वयन नहीं है. बल्कि, इस कार्यान्वयन को इसलिए चुना गया क्योंकि यह स्काला के कुछ कार्यात्मक प्रोग्रामिंग विचारों को प्रदर्शित करता है। स्काला सीखने में एक अच्छा अभ्यास है इसका संदर्भ लेना स्काला एपीआई और यह स्काला ट्यूटोरियल उपरोक्त ऑब्जेक्ट परिभाषा को समझने के लिए, फिर मैन्युअल रूप से पता लगाएं कि जब प्रोग्राम दो कमांड लाइन तर्कों, "H" और "HQ9+" के साथ चलाया जाता है तो क्या होता है। यहां कुछ उपयोगी लिंक दिए गए हैं: मानचित्र वर्ग, मानचित्र वस्तु, फोल्डलेफ्ट विधि, कार्य1 विशेषता, विकल्प वर्ग, और अनुप्रयोग विशेषता.

तीन घंटे का दौरा

स्काला के बारे में और अधिक जानने के लिए, आप ले सकते हैं स्काला का दौरा. स्काला के प्रकार प्रणाली, पैटर्न मिलान, एक्टर्स समवर्ती लाइब्रेरी और बहुत कुछ पर कुछ आकर्षक तकनीकी पेपर यहां पाए जा सकते हैं। स्काला पेपर्स और वार्ता.

स्काला न केवल दिलचस्प है, बल्कि यह एक बहुत ही स्वच्छ और उत्पादक भाषा है। मेरा सुझाव है कि आप इसे टेस्ट ड्राइव के लिए ले जाएं - आप निश्चित रूप से कुछ नया सीखेंगे।

डेविड जे. बायसैक एक सॉफ्टवेयर डेवलपर है एसएएस.