स्काला की वापसी क्यों हुई लेकिन टूटती नहीं और जारी रहती है

Question

स्काला के पास breakया नहीं है continue, इसलिए कुछ लूप व्यवहार थोड़ा अधिक सोच लेता है।

एक लूप को जल्दी समाप्त करने के लिए पूंछ की पुनरावृत्ति, अपवाद या scala.util.control.Breaks(जो अपवाद का उपयोग करता है) की आवश्यकता होती है।

इसके लिए तर्क यह है कि, जैसे goto, वे प्रवाह निर्माण हैं जो अस्पष्ट प्रवाह करते हैं, और बेहतर, कम आश्चर्यजनक तरीकों से पूरा किया जा सकता है।

लेकिन ऐसा लगता है कि उन्हीं तर्कों का इस्तेमाल किया जा सकता है return।

क्यों स्काला जानबूझ कर छोड़ किया था breakऔर continueनहीं, बल्कि return?

Comments

मैं कल्पना कर सकता हूं कि भाषा के लेखक पुनरावृत्ति को निर्माण का तरीका मानते हैं । मैं कल्पना कर सकता हूं breakऔर continueकुछ अतिरिक्त सफाई मशीनरी की जरूरत है। OTOH returnकिसी कार्य को व्यवस्थित रूप से समाप्त करने का एक तरीका है, और कोई भी सफाई मशीनरी पहले से ही है।

— 9000

नहीं है breakable { for { break; } }, लेकिन एक बाद का विचार है, और संभावना दूर कुशल से।

— जोप एगेगन

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

— वेलेंनट्री

यह प्रश्न ऐसा लगता है कि इसका उत्तर यहाँ है: stackoverflow.com/questions/3770989/…

— माइकल शॉ

@PaulDraper: आपके प्रश्न का उत्तर breakऔर continueआपके प्रश्न के लिंक में निहित है। के लिए सवाल returnठीक वही है जो मैं जुड़ा हुआ था, जिसके बारे में सवाल था, और उसका जवाब दिया गया था, कम से कम शीर्ष-मतदान में, स्वीकृत जवाब। यदि दो उत्तर एक साथ रखे जाते हैं तो आपके प्रश्न का उत्तर नहीं मिलता है, हो सकता है कि आप इसे स्पष्ट करने के लिए प्रश्न को संपादित कर सकें।

— माइकल शॉ

Answer 1

ब्रेक और जारी रखें:

में स्काला के बारे में बात करते हैं , मार्टिन ओडर्स्की 3 कारण तोड़ने को शामिल करने या स्लाइड 22 पर जारी रखने के लिए नहीं दिया:

• वे थोड़ा अत्यावश्यक हैं; बेहतर कई छोटे कार्यों का उपयोग करें।
• मुद्दों को बंद करने के साथ कैसे बातचीत करें।
• उनकी जरूरत नहीं है!

और फिर वह कहता है, "हम पुस्तकालयों में विशुद्ध रूप से उनका समर्थन कर सकते हैं।" स्लाइड 23 पर, वह कोड देता है जो लागू करता है break। हालाँकि, मैं नहीं जानता कि स्काला को निश्चित रूप से अच्छी तरह से पता है, यह उस स्लाइड पर छोटी स्निपेट की तरह दिखता है, जिसे लागू करने के लिए सभी आवश्यक हैं break, और continueइसे उसी कोड में लागू किया जा सकता है जो समान रूप से छोटा है।

पुस्तकालयों में इस तरह से सामान को लागू करने में सक्षम होने के कारण मूल भाषा सरल हो जाती है।

मार्टिन ओडस्की, लेक्स स्पून और बिल वेनर्स द्वारा 'स्कैलांग, द्वितीय संस्करण' में प्रोग्रामिंग में, निम्नलिखित स्पष्टीकरण दिया गया है:

आपने ध्यान दिया होगा कि वहाँ का कोई जिक्र नहीं किया गया है breakया continue। स्काला इन आदेशों को छोड़ देता है क्योंकि वे फ़ंक्शन शाब्दिक रूप से अच्छी तरह से जाल नहीं करते हैं ... यह स्पष्ट है कि लूप के continueअंदर क्या मतलब है while, लेकिन फ़ंक्शन शाब्दिक के अंदर इसका क्या मतलब होगा? ... बिना प्रोग्राम के कई तरीके हैं breakऔर continue, और यदि आप फंक्शन शाब्दिक का लाभ लेते हैं, तो वे विकल्प अक्सर मूल कोड से कम हो सकते हैं।

वापसी:

रिटर्न को शैली में थोड़ा जरूरी माना जा सकता है, क्योंकि वापसी एक क्रिया है, कुछ करने की आज्ञा। लेकिन उन्हें एक विशुद्ध रूप से कार्यात्मक / घोषणात्मक तरीके से भी देखा जा सकता है: वे परिभाषित करते हैं कि फ़ंक्शन का रिटर्न मान क्या है (भले ही, कई रिटर्न वाले फ़ंक्शन में, वे केवल प्रत्येक एक आंशिक परिभाषा देते हैं)।

उसी पुस्तक में, वे निम्नलिखित के बारे में कहते हैं return:

किसी भी स्पष्ट returnकथन की अनुपस्थिति में , एक स्काला विधि विधि द्वारा गणना की गई अंतिम मान लौटाती है। विधियों के लिए अनुशंसित शैली वास्तव में स्पष्ट और विशेष रूप से कई, returnबयानों से बचने के लिए है । इसके बजाय, प्रत्येक विधि को एक मूल्य के रूप में अभिव्यक्ति के रूप में सोचें, जो वापस आ गया है।

विधियाँ समाप्त हो जाती हैं और मान लौटाते हैं, भले ही किसी returnकथन का उपयोग न किया गया हो, इसलिए क्लोजर के साथ कोई समस्या नहीं हो सकती है, क्योंकि अन्यथा क्लोजर कार्य अवधि नहीं होगा।

फ़ंक्शन शाब्दिक रूप से अच्छी तरह से मेष करने में कोई समस्या नहीं हो सकती है, क्योंकि फ़ंक्शन को वैसे भी एक मूल्य वापस करना है।

Comments

वापसी के संबंध में, कुछ हल्के खतरे प्रतीत होते हैं: tpolecat.github.io/2014/05/09/return.html

— bbarker

Answer 2

मुझे लगता है कि पिछले उत्तर अपेक्षाकृत अप्रकाशित संदर्भों के साथ, स्कैला के लिए breakया continueभाषा-व्यापी तरीके से शब्दार्थ को परिभाषित करने की समस्याओं के साथ न्याय करते हैं ।

मैंने एक छोटी सी लाइब्रेरी लिखी जो परिभाषित करती है breakऔर continueअधिक विवश संदर्भ में: स्कैला फॉर-कॉम्प्रिहेंशन के माध्यम से दृश्यों पर पुनरावृत्ति। उस संदर्भ पर ध्यान केंद्रित करने से, मेरा मानना ​​है कि शब्दार्थ अस्पष्ट और आसान हो जाता है।

पुस्तकालय यहाँ उपलब्ध है: https://github.com/erikerlandson/breakable

यहाँ एक सरल उदाहरण है कि यह कोड में कैसा दिखता है:

scala> import com.manyangled.breakable._
import com.manyangled.breakable._

scala> val bkb2 = for {
     |   (x, xLab) <- Stream.from(0).breakable   // create breakable sequence with a method
     |   (y, yLab) <- breakable(Stream.from(0))  // create with a function
     |   if (x % 2 == 1) continue(xLab)          // continue to next in outer "x" loop
     |   if (y % 2 == 0) continue(yLab)          // continue to next in inner "y" loop
     |   if (x > 10) break(xLab)                 // break the outer "x" loop
     |   if (y > x) break(yLab)                  // break the inner "y" loop
     | } yield (x, y)
bkb2: com.manyangled.breakable.Breakable[(Int, Int)] = com.manyangled.breakable.Breakable@34dc53d2

scala> bkb2.toVector
res0: Vector[(Int, Int)] = Vector((2,1), (4,1), (4,3), (6,1), (6,3), (6,5), (8,1), (8,3), (8,5), (8,7), (10,1), (10,3), (10,5), (10,7), (10,9))