"रिटर्न" का उपयोग करने से ? लेबल के लिए दिलचस्प प्रभाव पड़ता है (ट्राइऑप क्वेश्चनमार्क ऑपरेटर चीज़)।

ब्रेक के बजाय कीवर्ड के रूप में रिटर्न का प्रयोग करें?

@ मार्क-आईएम और @ जोशट्रिप्लेट पहले ही वापसी के खिलाफ जाऊंगा कि यह अभी भी एक अनसुलझा प्रश्न है।

ब्रेक (और जारी रखें) केवल लूप के साथ प्रयोग योग्य हैं।
यदि आप कुछ तोड़ सकते हैं, तो आप इसे जारी रख सकते हैं। (मुझे नहीं लगता कि किसी ब्लॉक पर जारी रखने के लिए चुनने के लिए कोई स्पष्ट वाक्यविन्यास है।)

C, C++, Java, C#, JavaScript और संभवत: अधिक भाषाओं में आप आमतौर पर break एक स्विच स्टेटमेंट में होते हैं ताकि फॉल-थ्रू को रोका जा सके। रस्ट ने इसे और बेहतर तरीके से हल किया है | पैटर्न में लेकिन उन भाषाओं से आने वाले लोग वास्तव में break को केवल लूप के लिए कुछ के रूप में नहीं देखेंगे। विशेष रूप से जावा और जावास्क्रिप्ट break माध्यम से भी सुविधा को उजागर करते हैं न कि return ।

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

किसी ब्लॉक को लेबल करने से मौजूदा लेबल रहित विराम में त्रुटियां नहीं होती हैं

सबसे पहले, मुझे लगता है कि यह बहुत ही कम होता है क्योंकि लेबल ब्रेक फीचर स्वीकार्य रूप से ऐसा कुछ नहीं है जिसका उपयोग प्रति 1000 लाइनों में 10 बार किया जाएगा। आखिरकार, यह केवल बिना लेबल वाले ब्रेक पर लागू होगा जो ब्लॉक की सीमा को पार करेगा, ब्लॉक के अंदर बिना लेबल वाले ब्रेक पर नहीं। दूसरा, जंग के उपयोगकर्ता संकलक द्वारा शिकायतों / त्रुटि संदेशों के आदी हैं, वे उन्हें खुशी से ठीक कर देंगे! तीसरा (यह सबसे मजबूत बिंदु है जो मुझे लगता है), यदि किसी ब्लॉक को लेबल करने के बजाय आप इसे लूप में लपेटते हैं, तो आपको पहले से ही बिना लेबल वाले ब्रेक के लिए देखना होगा और कोई त्रुटि संदेश नहीं है जो आसानी से ब्रेक स्टेटमेंट को सूचीबद्ध करता है, आपको मिल गया है खुद उनके लिए शिकार करने के लिए :)।

विशेष रूप से जावा और जावास्क्रिप्ट ब्रेक के माध्यम से भी सुविधा को उजागर करते हैं और वापस नहीं आते हैं।

यह मेरे लिए हत्यारा बिंदु है। ब्लॉक से ब्रेक कई भाषाओं में एक बात है। ब्लॉक से वापसी...इतना नहीं।

व्यक्तिगत रूप से, के प्रयोग पर मैं शेयर @joshtriplett के दृश्य break के बजाय return , लेकिन यह मुझे लग रहा था चर्चा की तरह आरएफसी पर हल नहीं किया गया था ... आप प्रश्न विश्वास करते हैं लैंग टीम में हल हो गया है, एक नोट के साथ बॉक्स पर टिक करें =)

बस इतना कह रहा हूं कि मैं इस पर काम कर रहा हूं। गुरु के निर्देशों की आवश्यकता नहीं है। बस किसी भी प्रयास की नकल नहीं करने के लिए। जल्द ही एक पीआर की अपेक्षा करें।

मैं अभी भी return से अधिक break पक्ष में हूं, लेकिन मैं यहां असहमत होने के लिए सहमत हो सकता हूं। प्रश्न हल हो गया।

वर्तमान में ( rustc 1.28.0-nightly (a1d4a9503 2018-05-20) ) rustc लेबल वाले ब्लॉक पर unsafe अनुमति नहीं देता है। क्या यह अपेक्षित है?

@topecongiro हां, मेरा मानना ​​​​है कि यह जानबूझकर है कि वर्तमान में केवल सादे ब्लॉक पर ही इसकी अनुमति है। यह भविष्य में बदल सकता है, लेकिन यह देखते हुए कि यह इतनी निम्न-स्तरीय और असामान्य विशेषता है, मेरा झुकाव प्रतिबंध के बजाय एक विशेषता होने की ओर है। (चरम पर, मुझे निश्चित रूप से else 'a: { ।)

निश्चित रूप से सहमत हैं। असुरक्षित + असामान्य नियंत्रण प्रवाह कुछ हतोत्साहित करने वाला लगता है।

एक चुटकी में, हालांकि, आप इसका उपयोग कर सकते हैं:

'a: {
unsafe {...}
}

सही?

असल में, अन्य सभी एक नया शब्दावली दायरा बनाते हैं, यह एक ब्लॉक नहीं है। संपूर्ण if-else एक ब्लॉक (थोड़े) है। तो नहीं, आपको else 'a: { नहीं मिलेगा आपको 'a: if ... else { मिलेगा।

else में एक ब्लॉक (अभिव्यक्ति) है। ब्लॉक के बिना कोई "नया शाब्दिक दायरा" नहीं है।
else से भी बदतर सतह सिंटैक्स स्थिति 'a: while foo 'b: {...} ।
(दिलचस्प रूप से, continue 'a break 'b , हम कम से कम आंतरिक रूप से उस पर भरोसा करना चाहेंगे)

(दिलचस्प रूप से, continue 'a break 'b , हम कम से कम आंतरिक रूप से उस पर भरोसा करना चाहेंगे)

यह एक महान अवलोकन है!

मुझे लगता है कि लेबल ब्लॉक-युक्त अभिव्यक्तियों का हिस्सा होना चाहिए, स्वयं को अवरुद्ध नहीं करना चाहिए। इसके लिए हमारे पास पहले से ही loop । (जैसा कि होता है, एक सादा ब्लॉक स्वयं भी एक ब्लॉक-युक्त अभिव्यक्ति है। लेकिन if और loop जैसी चीजें ब्लॉक-युक्त अभिव्यक्तियां हैं जो मुझे लगता है कि ब्लॉक नहीं हैं।)

( while या for जैसी चीजों को लेबल-ब्रेक-वैल्यू का समर्थन नहीं करना चाहिए, क्योंकि वे सामान्य रूप से या break साथ पूरा करते हैं या नहीं, इस आधार पर वे एक मान वापस नहीं कर सकते हैं या नहीं कर सकते हैं ।)

@eddyb

(दिलचस्प रूप से, जारी रखें 'ए ब्रेक है' बी, हम कम से कम आंतरिक रूप से उस पर भरोसा करना चाहेंगे)

केवल अगर break 'b लूप की स्थिति को फिर से जांचता है ...

@ मार्क-आईएम यह 'a: while foo {'b: {...}} के बराबर है, break लूप की स्थिति की जांच नहीं करेगा, लूप स्वयं होगा, क्योंकि बॉडी ब्लॉक के प्रत्येक पुनरावृत्ति से पहले लूप की स्थिति की जांच की जाती है।

वाह, मुझे लगता है कि _highly_ सहज ज्ञान युक्त नहीं है। मुझे उम्मीद है कि break 'b मूल रूप से goto 'b , जिसका अर्थ है कि हम कभी भी लूप बॉडी से बाहर नहीं निकलते हैं और स्थिति की दोबारा जांच नहीं की जाती है ...

ओह: man_facepalming: अच्छा...

यही कारण है कि मुझे लेबल ब्रेक/जारी रखना पसंद नहीं है:/

ठीक है, हमारे पास विशेष रूप से इन अजीब आंतरिक ब्लॉकों को लेबल करने की क्षमता break हमेशा मतलब होता है "इस ब्लॉक को छोड़ दें" और, उपरोक्त प्रतिबंध को देखते हुए, इसका मतलब "संबंधित क्लोजिंग ब्रेस के बाद मौके पर जाना" के अलावा और कुछ नहीं है।

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

ठीक है, मैं समझता हूं कि प्रोग्रामिंग भाषाओं के साथ एक्सेसिबिलिटी एक बड़ा मुद्दा है ... हालांकि, अगर आप मेरे जैसे कोड लिखते हैं तो लेबल ब्रेक बेहद उपयोगी है।

तो, हम लेबल किए गए ब्रेक को और अधिक सुलभ कैसे बना सकते हैं?

तो, हम लेबल किए गए ब्रेक को और अधिक सुलभ कैसे बना सकते हैं?

यह एक अच्छा सवाल है। मेरे पास कुछ विचार थे:

• हमें कुछ नमूने एकत्र करने चाहिए कि लोग जंगली में इसका उपयोग कैसे करते हैं। हम अवांछित पैटर्न या आलसी आदतों की तलाश कर सकते हैं।
• जब लेबल ब्रेक/जारी रखने के लिए इसे खराब अभ्यास माना जाता है तो हमारे पास राय शैली होनी चाहिए।
• हम कुछ पैटर्न के लिए लिंट जोड़ने में सक्षम हो सकते हैं जिन्हें यांत्रिक रूप से लूप/इटरेटर कॉम्बिनेटर में बदल दिया जा सकता है (हालांकि, मैं अपने सिर के ऊपर से ऐसे किसी भी पैटर्न के बारे में नहीं सोच सकता)।

पहले (स्वीकार्य रूप से पक्षपाती) नमूने के रूप में, वास्तविक कोड में लेबल ब्रेक के साथ मेरी आखिरी (और पहली) मुठभेड़ तारकीय नहीं थी: https://github.com/rust-lang/rust/pull/48456/files#diff -3ac60df36be32d72842bf5351fc2bb1dL51। मैं सम्मानपूर्वक सुझाव देता हूं कि यदि मूल लेखक ने थोड़ा और प्रयास किया होता तो वे उस मामले में पूरी तरह से लेबल ब्रेक का उपयोग करने से बच सकते थे ... यह उस तरह के अभ्यास का एक उदाहरण है जिसे मैं संभव होने पर हतोत्साहित करना चाहूंगा।

वह है... लेबल ब्रेक नहीं?

इसमें break और continue desugar के बारे में, जिसका उल्लेख RFC के लेखक द्वारा मूल RFC चर्चा में भी किया गया था; देखें https://github.com/rust-lang/rfcs/pull/2046#issuecomment -312680877

मुझे लगता है कि नाम break उप-इष्टतम है, लेकिन यह लूप के लिए अच्छी तरह से स्थापित है। एक अधिक "सैद्धांतिक" दृष्टिकोण सिंटैक्स का उपयोग करना होगा return 'a value , जो उस ब्लॉक के लिए मूल्य value का उपयोग करके, ब्लॉक 'a बाद "बाद" निष्पादन को तुरंत जारी रखता है।

@ मार्क-आईएम "एक सुविधा का उपयोग नहीं कर रहा है क्योंकि यह पहुंच योग्य नहीं है" "सुविधा को सुलभ बनाना" नहीं है।

हम लेबल किए गए ब्रेक को कैसे बदल सकते हैं ताकि मुझे भाषा की पूर्ण अभिव्यंजक शक्ति मिल जाए, साथ ही साथ आप शिकायत करना बंद कर दें कि आपका मस्तिष्क प्रवाह नियंत्रण चीजों के साथ-साथ संकलक को भी संसाधित नहीं कर सकता है?

(साथ ही, आपके द्वारा लिंक किया गया कोड RFC 2046/लेबल-ब्रेक-वैल्यू के साथ नहीं लगता है... क्या आपने शायद गलत कोड लिंक किया है?)

वह है... लेबल ब्रेक नहीं?

(साथ ही, आपके द्वारा लिंक किया गया कोड RFC 2046/लेबल-ब्रेक-वैल्यू के साथ नहीं लगता है... क्या आपने शायद गलत कोड लिंक किया है?)

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

@ मार्क-आईएम "एक सुविधा का उपयोग नहीं कर रहा है क्योंकि यह पहुंच योग्य नहीं है" "सुविधा को सुलभ बनाना" नहीं है।

हम लेबल किए गए ब्रेक को कैसे बदल सकते हैं ताकि मुझे भाषा की पूर्ण अभिव्यंजक शक्ति मिल जाए, साथ ही साथ आप शिकायत करना बंद कर दें कि आपका मस्तिष्क प्रवाह नियंत्रण चीजों के साथ-साथ संकलक को भी संसाधित नहीं कर सकता है?

क्षमा करें, मेरा मतलब शिकायत करने का नहीं है। अगर मैं अकेला व्यक्ति हूं जो इस तरह महसूस करता है, तो मुझे अलग होने में कोई फर्क नहीं पड़ता।

आईएमएचओ, यह लेबल किए गए ब्रेक/जारी रखने के साथ एक मौलिक समस्या है: यह _too_ अभिव्यक्तिपूर्ण है, और इसे कम करने का एकमात्र तरीका यह है कि "अच्छी शैली" (जो भी इसका मतलब है) के रूप में अनुशंसित उपयोग करना है। उदाहरण के लिए, "केवल लूप बॉडी के आरंभ या अंत से मूल्य के साथ लेबल किए गए ब्रेक का उपयोग करें (बीच में नहीं)।" इसका मतलब यह होगा कि एक मूल्य के साथ लूप से बाहर निकलने के संभावित तरीके स्पॉट करना और इसके बारे में तर्क करना आसान है।

इस प्रकार मैं अन्य भाषाओं में गोटो/लेबल ब्रेक से बचता हूं: https://gist.github.com/SoniEx2/fc5d3614614e4e3fe131/#file -special-lua-L4-L72

क्या यह अधिक पठनीय है?

यदि ऐसा है, तो शायद हम लेबल वाले ब्लॉकों के आधार पर किसी प्रकार की सशर्त प्रणाली का पता लगा सकते हैं। करने के लिए इसी तरह के इस , हो सकता है।

लेबल रहित ब्रेक और जारी रखने का बिंदु उन मामलों को प्रदान करना है जहां आप लूप हेडर में आसानी से स्थिति/मान नहीं डाल

लेबल किए गए ब्रेक और लूप में जारी रखने का बिंदु समान है- कभी-कभी एकमात्र विकल्प एक नया चर, एक नया फ़ंक्शन (जिससे return दुरुपयोग होता है), या कुछ अन्य गर्भपात होता है जो केवल चीजों का पालन करना कठिन बनाता है, हालांकि दुर्भाग्य से जटिल एक लेबल विराम हो सकता है।

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

आपके उदाहरण के बारे में मेरा यही मतलब था, @ मार्क-इम- यह लेबल वाले ब्लॉक के बजाय लेबल वाले लूप का काफी मानक उपयोग था।

एक अधिक "सैद्धांतिक" दृष्टिकोण सिंटैक्स रिटर्न 'एक मान का उपयोग करना होगा, जो उस ब्लॉक के मूल्य मान का उपयोग करके ब्लॉक' ए के बाद तुरंत निष्पादन जारी रखता है।

break बनाम return बारे में साइड नोट: मैं break पसंद करता हूं क्योंकि यह स्थिर नियंत्रण प्रवाह है। return गतिशील है, इसमें यह वापस कॉल करने वाले के पास जाता है, जो कहीं भी हो सकता है। इसका अर्थ है "मैंने अपनी ज़िम्मेदारी पूरी कर ली है, मैं क्या करता हूँ यह देखने के लिए और कहीं नहीं है।" break हमेशा कहीं न कहीं जाता है जो कि लेक्सिक रूप से दायरे में है, जैसे कि लूप के साथ।

मुझे लगता है कि return 'label expr "जो मैं कहता हूं" परिप्रेक्ष्य से वास्तव में अच्छी तरह से पढ़ता है जिसमें इसे "स्थान 'लेबल पर वापसी' के रूप में सोचा जा सकता है। मुझे नहीं लगता कि break 'label expr इस परिप्रेक्ष्य में समान रूप से अच्छी तरह से पढ़ता है ...

अन्य प्रोग्रामिंग भाषाओं से अलग, इसलिए मैंने return 'label expr वकालत की हो सकती है। हालांकि, अन्य भाषाओं में नियंत्रण प्रवाह को देखते हुए, return पुन: उपयोग करना अचानक बहुत कम व्यवहार्य विकल्प बन जाता है और यह मुझे break 'label expr पक्ष में ले जाता है।

मेरा दृढ़ मत है कि यह break 'label expr होना चाहिए न कि return 'label expr । अन्यथा करना लूप में हमारे break 'label मौजूदा उपयोग के साथ पूरी तरह से असंगत होगा।

@ SonyEx2 मुझे लगता है कि मैं आपके द्वारा पोस्ट किए गए स्निपेट को पसंद करता हूं, बड़े पैमाने पर क्योंकि चर लूप इनवेरिएंट को दस्तावेज करने का एक अच्छा तरीका है। ओटीओएच, लेबल के नामों के साथ ऐसा करना संभव हो सकता है (अर्थात किसी भी समय यह लेबल वाला ब्लॉक दर्ज किया जाता है, अपरिवर्तनीय पी धारण करता है)। मुझे लगता है कि यह एक ऐसी जगह है जहां जंगली से कुछ और कोड नमूने लेना अच्छा होगा ...

स्थिरीकरण प्रस्ताव

यह सुविधा https://github.com/rust-lang/rust/pull/50045 में @est31 द्वारा लागू की गई break को return बजाय सतह सिंटैक्स होना चाहिए।

इस प्रकार, मैं लेबल-ब्रेक-वैल्यू (RFC 2046) को स्थिर करने के लिए आगे बढ़ता हूं।

@rfcbot मर्ज

प्रतिवेदन

• फ़ीचर गेट:
  
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/feature-gates/feature-gate-label_break_value.rs
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
  
  
• निदान: https://github.com/rust-lang/rust/blob/master/src/librustc_passes/diagnostics.rs#L285
• परीक्षण:
  
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_continue.rs
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_unlabeled_break.rs
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_illegal_uses.rs
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/lint/unused_labels.rs
  
  
  • https://github.com/rust-lang/rust/blob/master/src/test/ui/run-pass/for-loop- while/label_break_value.rs
  
  

FCP . से पहले TODO

@rfcbot चिंता test

अंतिम परीक्षण फ़ाइल में वर्तमान में एक FIXME है:

// FIXME: ensure that labeled blocks work if produced by macros and in match arms

इसे स्थिर करने से पहले हल किया जाना चाहिए।
मैंने यह जांचने के लिए कुछ परीक्षण लिखे कि अपेक्षित व्यवहार wrt. FIXME वास्तव में लागू किया गया है:

// run-pass

#![feature(label_break_value)]

#[test]
fn lbv_match_test() {
    fn test(c: u8, xe: u8, ye: i8) {
        let mut x = 0;
        let y = 'a: {
            match c {
                0 => break 'a 0,
                v if { if v % 2 == 0 { break 'a 1; }; v % 3 == 0 } => { x += 1; },
                v if { 'b: { break 'b v == 5; } } => { x = 41; },
                _ => {
                    'b: {
                        break 'b ();
                    }
                },
            }
            x += 1;
            -1
        };

        assert_eq!(x, xe);
        assert_eq!(y, ye);
    }

    test(0, 0, 0);
    test(1, 1, -1);
    test(2, 0, 1);
    test(3, 2, -1);
    test(5, 42, -1);
    test(7, 1, -1);
}

#[test]
fn lbv_macro_test() {
    macro_rules! mac1 {
        ($target:lifetime, $val:expr) => {
            break $target $val;
        };
    }
    let x: u8 = 'a: {
        'b: {
            mac1!('b, 1);
        };
        0
    };
    assert_eq!(x, 0);
    let x: u8 = 'a: {
        'b: {
            if true {
                mac1!('a, 1);
            }
        };
        0
    };
    assert_eq!(x, 1);
}

// compile-fail

#![feature(label_break_value)]

fn lbv_macro_test_hygiene_respected() {
    macro_rules! mac2 {
        ($val:expr) => {
            break 'a $val;
        };
    }
    let x: u8 = 'a: {
        'b: {
            if true {
                mac2!(2);
            }
        };
        0
    };
    assert_eq!(x, 2);

    macro_rules! mac3 {
        ($val:expr) => {
            'a: {
                $val
            }
        };
    }
    let x: u8 = mac3!('b: {
        if true {
            break 'a 3;
        }
        0
    });
    assert_eq!(x, 3);
    let x: u8 = mac3!(break 'a 4);
    assert_eq!(x, 4);
}

इससे पहले कि हम प्रस्तावित-FCP से FCP में जाएँ, इनके समान परीक्षण जोड़े जाने चाहिए।

टीम के सदस्य @Centril ने इसे मर्ज करने का प्रस्ताव दिया है। अगला चरण बाकी टैग की गई टीमों द्वारा समीक्षा है:

• [x] @सेंट्रिल
• [x] @ एट्यूरॉन
• [एक्स] @ क्रैमर्टज
• [x] @eddyb
• [ ] @joshtriplett
• [x] @nikomatsakis
• [ ] @ एनआरसी
• [x] @pkfelix
• [x] @scottmcm
• [ ] @ नावों के बिना

चिंताओं:

• लागत-लाभ (https://github.com/rust-lang/rust/issues/48594#issuecomment-422235234)
• FIXME-in-tests (https://github.com/rust-lang/rust/issues/48594#issuecomment-421625182)
• उपयोग के मामले (https://github.com/rust-lang/rust/issues/48594#issuecomment-422281176)

एक बार जब अधिकांश समीक्षकों ने स्वीकृति दे दी (और कोई आपत्ति नहीं), तो यह अपनी अंतिम टिप्पणी अवधि में प्रवेश करेगा। यदि आपको कोई बड़ा मुद्दा मिलता है जिसे इस प्रक्रिया में किसी भी बिंदु पर नहीं उठाया गया है, तो कृपया बोलें!

टैग की गई टीम के सदस्य मुझे क्या आदेश दे सकते हैं, इस बारे में जानकारी के लिए

@rfcbot चिंता लागत-लाभ

RFC FCP प्रस्ताव से :

एक अन्य समूह ने महसूस किया कि भाषा को इस सुविधा का "लागत लाभ" काफी कम नहीं हुआ। दूसरे शब्दों में, बढ़ी हुई जटिलता जो सुविधा लाएगी - एक और तरीका है, संभावना है कि लोग वास्तव में इसका उपयोग करेंगे और आपको उनका कोड पढ़ना होगा, मुझे लगता है, साथ ही साथ भाषा का समग्र आकार - उपयोगिता के अनुरूप नहीं था।

मुझे अभी भी नहीं लगता कि हमारे पास यह सुविधा होनी चाहिए। जब से इसे लागू किया गया है, क्या इसका बहुत उपयोग किया गया है? जिन मामलों में इसका उपयोग किया गया है, क्या यह कार्यों का उपयोग करने के लिए काफी खराब है? यदि यहां कोई लाभ है, तो क्या यह भाषा को बड़ा और अधिक जटिल बनाने की लागत से अधिक है?

@nrc मैं एक ही चिंता साझा करता हूं। मैं इसे उपलब्ध कराने के तर्क को समझता हूं ताकि मैक्रोज़ इसका उपयोग कर सकें, लेकिन साथ ही, मेरे पास यह बिल्कुल नहीं होगा।

मैं मूल आरएफसी धागे से चढा तर्क नहीं करना चाहता, लेकिन मुझे लगता है कि यह इस सुविधा के साथ अनुभवों के बारे में पूछने के लिए एक उचित बिंदु है लगता है। इसका क्या उपयोग देखा है?

हस्तलिखित पार्सर, अधिकतर... (मुझे अपने हस्तलिखित पार्सर पसंद हैं >.<)

लेबल-प्रचार ( try_foo() 'bar? ) के साथ उपयोग करना अधिक उपयोगी/आसान होगा।

@rfcbot चिंता का विषय उपयोग के मामले

डिस्कॉर्ड पर कुछ चर्चाओं को सारांशित करना: हम वास्तविक कोड से इसके लिए ठोस उपयोग के मामलों को देखना चाहते हैं, जो इस सुविधा का उपयोग न करने के लिए फिर से लिखे जाने पर अधिक स्पष्ट रूप से सामने नहीं आते हैं।

~ एफडब्ल्यूआईडब्ल्यू, EXPR is PAT का मेरा कार्यान्वयन break 'label value पर कम से कम एएसटी में उपलब्ध होने पर निर्भर करता है, मुझे नहीं पता कि इसके बिना desugaring कैसे काम कर सकता है।
का कार्यान्वयन EXPR? संकलक में पर निर्भर करता है break 'label value में अच्छी तरह से। ~

~ यह बड़े नियंत्रण प्रवाह सुविधाओं के लिए किसी प्रकार का बुनियादी निर्माण खंड है, इसलिए इसे वैसे भी संकलक में लागू करने की आवश्यकता हो सकती है।
तो यहां "लागत" शायद इसे सतह वाक्यविन्यास में उपलब्ध करा रही है। ~

संपादित करें: मैंने इस मुद्दे की पूरी तरह से गलत व्याख्या की है, हालांकि यह लगभग loop { ... break 'label value ... } , { ... break 'label value ... } अवरुद्ध नहीं करता है।
मुझे इसे आजमाने का कभी मौका नहीं मिला क्योंकि मैं हमेशा भूल जाता हूं कि यह पहले ही लागू हो चुका है।

@petrochenkov कलह पर @joshtriplett से बात कर, वे ने कहा कि वे उपयोगकर्ता-उन्मुख जटिलता, नहीं भाषा के कार्यान्वयन के बारे में चिंतित थे।

मुझे लगता है कि जटिलता वृद्धि न्यूनतम है: पाठकों के लिए, यह स्पष्ट होना चाहिए कि इसका क्या अर्थ है क्योंकि अवधारणा पहले से ही लूप में मौजूद है, आदि।
मुझे अन्यथा बिना शर्त ब्रेक स्टेटमेंट के साथ एक लूप का उपयोग करना होगा, जो कम स्पष्ट है और वास्तव में इसके बारे में एक क्लिपी लिंट (नेवर_लूप) भी है। तो मुझे लगता है कि एक फायदा है।

उपयोग के मामलों के लिए, वह विषय पहले ही आरएफसी में आ चुका है। मैंने यहां अपने उपयोग के मामले की ओर इशारा किया। सीधे नीचे @joshtriplett क्या उपयोग के मामले के प्रश्न को हल करता है?

मैं @nrc और @joshtriplett से सहमत हूं और मैं यहां एक प्रक्रिया की चिंता भी उठाना चाहता हूं: हमने इस RFC को एक स्पष्ट चेतावनी के साथ अस्थायी रूप से स्वीकार कर लिया है कि @nrc और @joshtriplett द्वारा उठाए गए प्रश्नों पर फिर से विचार करने पर स्थिरीकरण अवरुद्ध हो गया था, लेकिन @Centril के मर्ज प्रस्ताव इस अवरुद्ध चिंता का बिल्कुल भी उल्लेख नहीं करता है, और इसे एक बहुत ही मानक "फीचर बेक किया हुआ" मर्ज के रूप में मानता है। मैं इसके लिए @Centril को दोष नहीं दे रहा हूं, लेकिन एक प्रक्रिया टूटने पर: यदि हम स्थिरीकरण पर अनसुलझे अवरोधकों के साथ सुविधाओं को अस्थायी रूप से स्वीकार करने जा रहे हैं, तो हमें उन अवरोधकों को ट्रैक करने की आवश्यकता है।

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

@withboats हाँ, बिल्कुल। यह मुझे भविष्य में, "स्थिरीकरण प्रक्रिया के दौरान हम XYZ करेंगे" के आधार पर चीजों को स्वीकार करने के लिए कम इच्छुक बनाता है, जब तक कि हमारे पास कुछ ऐसी प्रक्रिया न हो जो इसे अत्यधिक असंभव बना देती है जो छूट जाएगी।

@ नावों के बिना

मैं इसके लिए @Centril को दोष नहीं दे रहा हूं, लेकिन एक प्रक्रिया टूटने पर: यदि हम स्थिरीकरण पर अनसुलझे अवरोधकों के साथ सुविधाओं को अस्थायी रूप से स्वीकार करने जा रहे हैं, तो हमें उन अवरोधकों को ट्रैक करने की आवश्यकता है।

फिर भी माफ़ी; मैं चेतावनी से अनजान था, लेकिन जब मैंने ट्रैकिंग समस्या बनाई तो मुझे ऐसी चीजों की जांच करनी चाहिए थी।

यह पिछले समझौते के एक तोड़फोड़ की तरह लगता है जिसके कारण मुझे आरएफसी के विलय के लिए सहमति हुई, और मुझे लगता है कि यह पूरी तरह से जानकारी की अपर्याप्त ट्रैकिंग के कारण है।

मुझे इसके लिए एक अनसुलझा प्रश्न बनाना चाहिए था; मेरा मानना ​​है कि उस समय प्रक्रिया में गलती हुई थी।
प्रक्रिया में सुधार कैसे करें; मुझे लगता है कि यह महत्वपूर्ण है कि अनसुलझे प्रश्न RFC के _text_ में आ

जहाँ तक FCP-मर्ज प्रस्ताव का संबंध है; मुझे व्यक्तिगत रूप से लगता है कि यह एकरूपता के कारणों और मैक्रोज़ द्वारा उपयोग के लिए उपयोगी होगा। हालाँकि, यदि आप मानते हैं कि स्थिरीकरण का प्रस्ताव देना जल्दबाजी होगी; प्रस्ताव को रद्द करने के लिए स्वतंत्र महसूस करें :)

@est31

मुझे अन्यथा बिना शर्त ब्रेक स्टेटमेंट के साथ लूप का उपयोग करना होगा,

या या तो बचने के लिए कोड का पुनर्गठन करें।

मैंने यहां अपने उपयोग के मामले की ओर इशारा किया।

break 'pseudo_return को return Ok(vectors); क्यों न बदलें?

जैसा कि मैंने यहां उल्लेख किया try_foo() 'bar? ))।

लेबल-ब्रेक-वैल्यू अन्यथा कार्यात्मक कोड की आसान अनिवार्यता की अनुमति देता है। आम तौर पर, अनिवार्य कोड कार्यात्मक कोड की तुलना में अधिक पठनीय होता है।

या या तो बचने के लिए कोड का पुनर्गठन करें।

बेशक, जंग ट्यूरिंग पूरा हो गया है। लेकिन पुनर्गठन थोड़ा मुश्किल हो सकता है। कुल मिलाकर, आप "आप मौजूदा तरीकों का उपयोग कर सकते हैं" के आधार पर लगभग हर चीनी सुविधा (और यह चीनी सुविधा है) को अस्वीकार कर सकते हैं।

ब्रेक 'pseudo_return को रिटर्न ओके (वैक्टर) से क्यों न बदलें;?

वास्तव में इस उदाहरण में आप सही हैं, कोई भी ब्रेक को रिटर्न ओके से बदल सकता है। लेकिन अन्य उदाहरणों में आप बाद में प्रसंस्करण करना चाहते हैं, आदि। उधार चेकर फ़ंक्शन सीमाओं में खराब काम करता है, आप ऐसे प्रत्येक ब्लॉक को फ़ंक्शन में कारक नहीं बना सकते हैं।

वैसे भी, मैंने आधिकारिक माध्यमों से भाषा सुविधाओं पर टिप्पणी करने के बारे में अपनी चुप्पी तोड़ी है, और मुझे इसका खेद है। सभी वही बिंदु, बार-बार दोहराए गए। यह बकवास मेरे समय की बर्बादी है, क्षमा करें। इसलिए मुझसे आगे किसी टिप्पणी की अपेक्षा न करें।

@ est31 मैं वास्तव में आपको विवरण प्रदान करने की सराहना करता हूं; शुक्रिया।

रात्रिकालीन रस्ट की आवश्यकता के कारण, इन चीज़ों के परीक्षण और उपयोग के लिए एक पहुँच-योग्यता समस्या है।

मैं स्थिर लक्ष्य रखता हूं। मुझे उम्मीद है कि किसी दिन इसे हल किया जा सकता है।

यदि हम उपयोग के मामले चाहते हैं, तो यहां एक है जिसे मैंने कुछ समय पहले मारा था; मूल रूप से @ est31 के "बाद में प्रसंस्करण करें" का विस्तार: मैंने एक L , u8 एक संयोजन विस्फोट, u , U , }{ R , }), और बहु-बाइट टोकन जो उपयोग किए गए बाइट्स की संख्या में "अंतराल" के साथ (सुनिश्चित नहीं है कि कोई बिना समझ उदाहरण)। get_token फ़ंक्शन वर्तमान में इस तरह दिखता है:

fn get_token(&mut self) -> Token {
    match decode_byte(self.source) {
        // ...

        // repeat four times with small variations for b'U', b'L', and b'R':
        Some((b'u', rest)) => match decode_byte(rest) {
            Some((b'"', rest)) => self.string_literal(Utf16String, rest),
            Some((b'\'', rest)) => self.char_constant(Utf16Char, rest),
            Some((b'R', rest)) => match decode_byte(rest) {
                Some((b'"', rest)) => self.raw_string_literal(Utf16String, rest),
                _ => self.identifier(rest),
            },
            Some((b'8', rest)) => match decode_byte(rest) {
                Some((b'"', rest)) => self.string_literal(Utf8String, rest),
                Some((b'\'', rest)) => self.char_constant(Utf8Char, rest),
                Some((b'R', rest)) => match decode_byte(rest) {
                    Some((b'"', rest)) => self.raw_string_literal(Utf8String, rest),
                    _ => self.identifier(rest),
                },
                _ => self.identifier(rest),
            },
            _ => self.identifier(rest),
        },

        // ...

        // the "gap" mentioned above is here: single-byte '.' and triple-byte '...' but no double-byte '..':
        Some((b'.', rest)) => match decode_byte(rest) {
            Some((b'0'..=b'9', rest)) => self.number(rest),
            // note the _inner to avoid shadowing the outer `rest` used by the inner `Dot` case:
            Some((b'.', rest_inner)) => match decode_byte(rest_inner) {
                Some((b'.', rest)) => self.make_token(Ellipsis, rest),
                _ => self.make_token(Dot, rest),
            },
            _ => self.make_token(Dot, rest),
        },

        // ...
    }
}

_ => self.identifier(rest) s के पिरामिडों पर ध्यान दें ( u , U , R , और L ) और _ => self.make_token(Dot, rest) लिए चार बार दोहराया गया identifier , string_literal , आदि सभी को make_token भी कॉल करना चाहिए।

मैं break -फ्रॉम-ब्लॉक का उपयोग करके चीजों को कम निरंतरता-वाई शैली में समेकित करना पसंद करता, और लगभग loop s लेबल के माध्यम से ऐसा करता था, लेकिन उस संस्करण को पढ़ने के लिए बहुत अजीब माना जाता था। अधिक विशिष्ट होना:

• मैं मुख्य match decode_byte(self.source) बाद सभी make_token कॉल को एक ही स्थान पर ले जाता, और इसे इनलाइन करता- यह छोटा है और इसमें unsafe और इसके इनवेरिएंट को get_token द्वारा सही ठहराया गया है।
• मैं प्रयोग किया जाता है | break 'label self.string_literal(..) खोजने एक बार शॉर्ट सर्किट के लिए एक " या ' , और तब सभी संयुक्त self.identifier(..) कि मैच हाथ के अंत के लिए कॉल .
  
  
  
  • मैं उपसर्गों के संयोजनीय विस्फोट को रैखिक रूप देने में भी सक्षम हो सकता हूं- u / u8 / U / L जांच करें, फिर R जांच करें break 'label s का उपयोग करता है, लेकिन फिर भी एक मुट्ठी भर।
  
  
• मैं का इस्तेमाल किया होता तो break 'label (Ellipsis, rest) शॉर्ट सर्किट के लिए एक पाने के लिए एक बार ... , और उसके बाद दोनों संयुक्त (Dot, rest) रों कि मैच हाथ के अंत तक।

कुल मिलाकर, यह मूल रूप से "अगर + जल्दी वापसी के साथ नियंत्रण प्रवाह को समतल करता है," चीजों को एक अलग फ़ंक्शन में निकालने की आवश्यकता के बिना। इस मामले में कुछ कारणों से यह अत्यंत मूल्यवान है:

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

मैं पूरी बात लिखूंगा लेकिन मुझे लगता है कि मैंने वह प्रयास कभी नहीं किया (शायद इसलिए कि मैं ऊपर सूचीबद्ध सभी समस्याओं में भाग गया) और मैंने पहले ही यहां पर्याप्त शब्द खर्च किए हैं। :)

@SergioBenitez क्या आप http://rocket.rs/ के label_break_value और स्थिरीकरण पर अपने विचारों के बारे में विस्तार से बता सकते हैं?

@सेंट्रिल ज़रूर! यहाँ सार है:

fn transform(request: &Request, data: Data) -> Transform<Outcome<_, _>> {
    let outcome = 'o: {
        if !request.content_type().map_or(false, |ct| ct.is_form()) {
            break 'o Forward(data);
        }

        let mut form_string = String::with_capacity(min(4096, LIMIT) as usize);
        if let Err(e) = data.read_to_string(&mut form_string) {
            break 'o Failure(FormDataError::Io(e));
        }

        Success(form_string)
    };

    Transform::Borrowed(outcome)
}

इस सुविधा का उपयोग करने से मैं बचता हूं:

• प्रारंभिक "रिटर्न" के लिए ब्लॉक को एक अलग फ़ंक्शन में विभाजित करना।
• ब्लॉक में प्रत्येक "रिटर्न" मान में Transform::Borrowed जोड़ना।
• यदि अलग-अलग मामलों में अलग Transform लौटाया जाता है तो संभावित गलतता।
  
  
  
  • नोट: यह रॉकेट और कोड के इस टुकड़े के लिए विशेष रूप से एक अपरिवर्तनीय है।
  
  

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

@SergioBenitez धन्यवाद! मुझे आश्चर्य है कि क्या आप (अंततः) इसे try { .. } साथ फिर से लिख सकते हैं? इस तरह:

fn transform(request: &Request, data: Data) -> Transform<Outcome<_, _>> {
    Transform::Borrowed(try {
        if !request.content_type().map_or(false, |ct| ct.is_form()) {
            Forward(data)?;
        }

        let mut form_string = String::with_capacity(min(4096, LIMIT) as usize);
        if let Err(e) = data.read_to_string(&mut form_string) {
            Failure(FormDataError::Io(e))?;
        }

        form_string
    })
}

@Centril हाँ, यह तब तक काम करेगा जब तक कि केवल एक ही सफलता का रास्ता है, जो यहाँ है।

या या तो बचने के लिए कोड का पुनर्गठन करें।

ऐसा करने से, आप अतिरिक्त शाखाओं या सबरूटीन कॉलों को जोड़ने का जोखिम उठाते हैं जिन्हें अनुकूलक द्वारा हल नहीं किया जा सकता है। मेरे लिए, ऐसा नियंत्रण प्रवाह परिवर्तन काफी जटिल कार्य प्रतीत होता है।

जिन मामलों में इसका उपयोग किया गया है, क्या यह कार्यों का उपयोग करने के लिए काफी खराब है? यदि यहां कोई लाभ है, तो क्या यह भाषा को बड़ा और अधिक जटिल बनाने की लागत से अधिक है?

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

मैं संभव सबसे सुंदर बाइनरी कोड पसंद करूंगा। आप इसे थोड़ा और उन्नत नियंत्रण प्रवाह द्वारा कर सकते हैं, लगभग किसी फ़ंक्शन से प्रारंभिक वापसी के समान।

मुझे आश्चर्य है कि क्या आप (अंततः) इसे try {..} के साथ फिर से लिख सकते हैं? इस तरह:
[...]

यह थोड़ा भ्रमित करने वाला लगता है, क्योंकि शाखाओं को पेश किया जाता है, बस इसे दूर करने के लिए। लेकिन कुछ स्थितियों में दोनों की आवश्यकता हो सकती है। इस प्रकार, होने

'a: {try{...}}

या

'a: try {...}

अच्छा होगा।

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

कृपया मुझे अपमानित करने के लिए स्वतंत्र महसूस करें:

• ऑपरेटर_मुल
• ऑपरेटर_गेट
• मुख्य घेरा

यह सबसे अच्छा कोड नहीं हो सकता है, लेकिन मैं चाहता था कि चीजें बिल्कुल काम करें।

मैं निरंतरता पासिंग शैली के संदर्भ में मुख्य लूप को एक राज्य मशीन के रूप में प्रयोगात्मक रूप से पुनर्स्थापित करना चाहता हूं। लेकिन निरंतरता और लागू टेल कॉल एक और विषय है।

जंगली में पाए गए कुछ उपयोगों को डंप करना:

• https://github.com/veloren/game/blob/12693916bc1f1620418f9cb18909b9f55875dbb3/server/src/msg.rs
• https://github.com/veloren/game/blob/8e4ddbeba89eb964d6939664414a68c9bb929968/client/src/world.rs
• https://github.com/Laaas/abstract-struct/blob/d8f52bc982aceef6a7bd4a07c6f776a12880e80b/macro/lib.rs
• https://github.com/71/rust-version-macro/blob/bc381d688a642e851e84fe4b05c38288489b227c/src/lib.rs

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

मैं @zesterer से सहमत

एफडब्ल्यूआईडब्ल्यू, मैंने हाल ही में इसे पहली बार कंपाइलर में इस्तेमाल किया था।
पैटर्न पिछले उदाहरणों की तरह ही है - हम कई स्थितियों की जाँच कर रहे हैं और यदि उनमें से कोई भी सत्य है तो हम जो कर रहे हैं उसे करना बंद कर देते हैं।
https://github.com/rust-lang/rust/blob/21f26849506c141a6760532ca5bdfd8345247fdb/src/librustc_resolve/macros.rs#L955 -L987

@erickt ने कुछ कोड भी लिखे जो उसी कारण से इसका उपयोग करना चाहते थे: कई स्थितियों की जाँच करना, उनमें से एक के गलत होने पर ब्रेक आउट हो जाना। आप इसे तत्काल-बंद-बंद या let _: Option<()> = try { ... None?; .. }; साथ नकली बना सकते हैं लेकिन दोनों बहुत हैकी हैं।

@withboats @nrc @joshtriplett क्या आपके पास विभिन्न लोगों द्वारा अब तक लाए गए उपयोग के मामलों पर कोई विचार है?

पिंग @withboats @nrc @joshtriplett :) - पिछली बैठक में हमने इस संभावना पर चर्चा की कि आप ऊपर दिए गए कुछ उदाहरणों को फिर से लिखने का प्रयास कर सकते हैं और हमें दिखा सकते हैं कि आप उनकी संरचना कैसे करेंगे।

मैं ग्रेडॉन के ब्लॉग पोस्ट द्वारा यहां एक टिप्पणी लिखने के लिए प्रेरित हुआ कि मैं इस सुविधा को स्थिर क्यों नहीं करना चाहता। मुझे लगता है कि इस प्रयोग के लिए सहमत होना मेरे लिए थोड़ा अनुचित था; नकारात्मक साबित करना मुश्किल है लेकिन मुझे नहीं पता कि भाषा में नियंत्रण प्रवाह के इस रूप को जोड़ने के लिए किस प्रकार का कोड नमूना मेरे विरोध को दूर कर सकता है।

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

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

इसके अलावा, मुझे लगता है कि इस सुविधा में एक और वास्तव में नकारात्मक गुण है: पश्चगामी संगतता के कारण अनियमितता। break लिए ब्लॉक से बाहर निकलना बहुत ही अनियमित है, यदि वे लेबल किए गए हैं, जब यह बिना लेबल वाले लूप से बाहर हो जाता है। यह सुविधा को समझने में कठिन बनाता है यदि यह नियमित होता, तो नकारात्मक विशेषताओं को ठीक उसी तरह से बढ़ाता है जहां मुझे लगता है कि वे सबसे खराब - बोधगम्यता हैं।

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

मुझे लगता है कि करने के लिए सही बात यह है कि इस सुविधा का उपयोग करने वाले प्रत्येक क्रेट को ढूंढें और कोड को फिर से लिखें ताकि इस सुविधा का उपयोग न किया जा सके।

@withboats मेरे द्वारा पकड़ी गई कई आपत्तियों को बहुत प्रभावी ढंग से व्यक्त करने के लिए धन्यवाद।

मैं आगे बढ़ूंगा और यहां बोल्ड रहूंगा:

@rfcbot रद्द करें
@rfcbot स्थगित

@joshtriplett प्रस्ताव रद्द कर दिया गया।

टीम के सदस्य @joshtriplett ने इसे टालने का प्रस्ताव रखा है। अगला चरण बाकी टैग की गई टीमों द्वारा समीक्षा है:

• [ ] @सेंट्रिल
• [ ] @ अटुरॉन
• [ ] @cramertj
• [ ] @eddyb
• [x] @joshtriplett
• [ ] @nikomatsakis
• [ ] @ एनआरसी
• [ ] @pkfelix
• [ ] @scottmcm
• [x] @ नावों के बिना

वर्तमान में कोई चिंता सूचीबद्ध नहीं है।

एक बार जब अधिकांश समीक्षकों ने स्वीकृति दे दी (और कोई आपत्ति नहीं), तो यह अपनी अंतिम टिप्पणी अवधि में प्रवेश करेगा। यदि आपको कोई बड़ा मुद्दा मिलता है जिसे इस प्रक्रिया में किसी भी बिंदु पर नहीं उठाया गया है, तो कृपया बोलें!

टैग की गई टीम के सदस्य मुझे क्या आदेश दे सकते हैं, इस बारे में जानकारी के लिए

@ नावों के बिना

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

मैं इस सिद्धांत से सहमत हूं, और मुझे लगता है कि यह सुविधा उस बार (विशिष्ट, महत्वपूर्ण उपयोग-मामलों पर लक्षित परिचित नियंत्रण प्रवाह) से मिलती है। कई बार जब मैंने ऊपर दिए गए उदाहरणों की तरह कोड की समीक्षा की या लिखा है, जहां मुझे लगता है कि यह इस कोड को लिखने का सबसे साफ और सबसे आसान तरीका है। अंत में बिना शर्त break loop साथ ? , await! , या अन्य मध्यवर्ती नियंत्रण-प्रवाह निर्माण।

loop + पीछे break का उपयोग करना भ्रमित करने वाला है, और इसके बजाय हमें यह पसंद करना चाहिए कि उपयोगकर्ता अपने वास्तविक इरादे को एक ऐसे टूल का दुरुपयोग करने की आवश्यकता के बारे में बताएं जो नियंत्रण-प्रवाह की एक अलग शैली के लिए बनाया गया था। यह इस तथ्य के समान है कि हमारे पास loop निर्माण भी है, जबकि अन्य भाषाएं while true { ... } संतुष्ट हैं। ऐसा करने से ऐसा कोड लिखना संभव हो जाता है जो अधिक स्पष्ट इरादे को व्यक्त करता है और परिणामस्वरूप अधिक पठनीय होता है।

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

टीएल; डीआर: मुझे लगता है कि यह सुविधा वास्तविक दुनिया के उपयोग-मामलों का समर्थन कर रही है जिसे केवल भारी-नेस्टेड- if स्टेटमेंट के माध्यम से या लूप-ब्रेक-वैल्यू जैसे अन्य निर्माणों का दुरुपयोग करके ही लिखा जा सकता है। यह सतह सिंटैक्स के लिए एक छोटा सा जोड़ है जो ब्लॉक को व्यवहार करता है जैसा कि मैं उनसे व्यवहार करने की अपेक्षा करता हूं और मुझे कुछ ज्यादा हैकर के बजाय मेरा मतलब कोड लिखने की अनुमति देता है।

@cramertj क्षमा करें, मैं थोड़ा उलझन में हूँ। ऐसा लगता है कि आप और @withboats / @joshtriplett एक दूसरे के ठीक विपरीत कह रहे हैं?

(fwiw, मैं @withboats /@joshtriplett से सहमत हूं)

@ मार्क-आईएम मैं उनसे सहमत नहीं हूं कि यह सुविधा बंद होनी चाहिए। मुझे लगता है कि इसे विलय किया जाना चाहिए (जैसा कि मेरी टिप्पणियों और ऊपर चिह्नित चेकबॉक्स द्वारा इंगित किया गया है)।

मैं @withboats से सहमत करेगी और विशिष्ट, महत्वपूर्ण उपयोग-मामलों से प्रेरित है।

@ नावों के बिना

मुझे लगता है कि इस प्रयोग के लिए सहमत होना मेरे लिए थोड़ा अनुचित था; नकारात्मक साबित करना मुश्किल है लेकिन मुझे नहीं पता कि भाषा में नियंत्रण प्रवाह के इस रूप को जोड़ने के लिए किस प्रकार का कोड नमूना मेरे विरोध को दूर कर सकता है।

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

मैं आगे बढ़ूंगा और यहां बोल्ड रहूंगा:

@rfcbot रद्द करें

@scottmcm का प्रस्ताव रद्द कर दिया गया।

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

यह निश्चित नहीं है कि इसका उल्लेख थ्रेड में किया गया था या नहीं, लेकिन break; द्वारा अलक्ष्यित होने वाले ब्लॉक कुछ अर्थों में लेबल किए गए loop s की तुलना में गुणात्मक रूप से अधिक शक्तिशाली बनाते हैं।

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

मेरे EXPR is PAT प्रोटोटाइप में मैंने शुरुआत में डिसुगरिंग के लिए सामान्य रूप से loop s का उपयोग किया था, लेकिन उपरोक्त मुद्दे के कारण चीजें टूट गईं, मैं विशेष रूप से कंपाइलर को बूटस्ट्रैप नहीं कर सका।
लेबल किए गए ब्लॉकों को तब लागू नहीं किया गया था, इसलिए मुझे एएसटी में एक विशेष "अनलक्षित loop " पेश करना पड़ा और इसे desugaring में उपयोग करना पड़ा।

जैसा कि मेरे चेकबॉक्स द्वारा दर्शाया गया है, मैं अभी इसे स्थिर करने के पक्ष में हूं। मुझे लगता है कि यह भाषा का एक स्वाभाविक विस्तार है जो मैक्रोज़ के साथ-साथ नियंत्रण प्रवाह की सुविधा प्रदान करता है जो इतनी आसानी से कार्यात्मक पैटर्न में फिट नहीं होता है। यहां तक ​​​​कि एनएलएल जीवन काल को गैर-व्याख्यात्मक बनाता है, मुझे लगता है कि जीवन काल के साथ ब्लॉकों को एनोटेट करने में सक्षम होने के कारण मुझे शैक्षणिक रूप से सहायक के रूप में भी प्रभावित करता है जैसे टाइप एस्क्रिप्शन करता है।

हालाँकि, चूंकि आम सहमति प्राप्त करना कठिन रहा है, इसलिए इसे खोजने के हित में, मैं सुझाव दूंगा कि हम try { ... } पर काम को गति देने के साथ-साथ https://github.com के साथ प्रयोग करने पर काम तेज करने का प्रयास @petrochenkov के EXPR is PAT सिंटैक्स के साथ)।

माफ़ करें, अब इसकी क्या स्थिति है? हम में हैं FCP या नहीं?

@mark-im चूँकि proposed-final-comment-period या final-comment-period में से कोई भी लेबल इस मुद्दे पर नहीं हैं, हम FCP या एक के प्रस्ताव में नहीं हैं।

(और हम में कभी नहीं किया गया है FCP, हालांकि प्रवेश करने के लिए एक प्रारंभिक प्रस्ताव था FCP सभी लेकिन तीन बक्से की जाँच के साथ)

@scottmcm

मैं आगे बढ़ूंगा और यहां बोल्ड रहूंगा:

@joshtriplett के शब्दों की यह पुनरावृत्ति मैंने बहुत व्यंग्यात्मक के रूप में पढ़ी। लैंग टीम के सदस्य के रूप में, कृपया विचार करें कि आप अन्य योगदानकर्ताओं के साथ कैसे संवाद करते हैं।

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

क्या किसी ने चीजों को धीमे, कम-सहज और कम-एर्गोनोमिक तरीके से फिर से लिखने की कोशिश की है?

ब्रेकिंग ब्लॉक एर्गोनोमिक गोटो की तरह है। इसमें गोटो के मुद्दों में से कोई भी नहीं है, लेकिन यह उतना ही शक्तिशाली है।

@nrc के हृदय परिवर्तन के आधार पर, मैं एक बार फिर label_break_value को स्थिर करने के लिए आगे बढ़ता हूं।
मेरी रिपोर्ट https://github.com/rust-lang/rust/issues/48594#issuecomment -421625182 में देखी जा सकती है।

@rfcbot मर्ज
@rfcbot चिंता test

यह सुनिश्चित करने के लिए कि @joshtriplett और @withboats के पास अभी भी किसी भी चिंता को उठाने का समय है, मैं ऐसी चिंता दर्ज करूंगा। जब वे मुझसे कहेंगे कि उन्हें ऐसी कोई चिंता नहीं है या जब उनमें से किसी ने अपनी चिंता व्यक्त की है तो मैं इसे उठाऊंगा।

@rfcbot चिंता देना-नाव-और-जोश-समय-से-उठाना-किसी भी-चिंता-वे-हो सकता है-अभी भी-है

इस मुद्दे के लिए और अन्य सभी के लिए एक प्रक्रिया नोट के रूप में, कृपया प्रस्तावों को आगे-पीछे रद्द करने से बचें... अगर आपको नहीं लगता कि कुछ आगे बढ़ना चाहिए, तो बस उसके लिए चिंताओं का उपयोग करें।

टीम के सदस्य @Centril ने इसे मर्ज करने का प्रस्ताव दिया है। अगला चरण बाकी टैग की गई टीम के सदस्यों द्वारा समीक्षा है:

• [x] @सेंट्रिल
• [x] @ एट्यूरॉन
• [एक्स] @ क्रैमर्टज
• [x] @eddyb
• [x] @joshtriplett
• [ ] @nikomatsakis
• [ ] @ एनआरसी
• [x] @pkfelix
• [ ] @scottmcm
• [ ] @ नावों के बिना

चिंताओं:

• ब्लॉक करना (https://github.com/rust-lang/rust/issues/48594#issuecomment-451673194)
• FIXME-in-tests (https://github.com/rust-lang/rust/issues/48594#issuecomment-451672226)
• दे-नौकाओं और जोश-टाइम-टू-उठाने-किसी भी-चिंताओं-वे-शक्ति-अभी भी है के द्वारा हल https://github.com/rust-lang/rust/issues/48594#issuecomment -+४५,१६,७३,२८२
• https://github.com/rust-lang/rust/issues/48594#issuecomment -632960804 द्वारा हल किया जाना चाहिए

एक बार जब अधिकांश समीक्षक स्वीकृति दे देते हैं (और अधिकतम 2 अनुमोदन बकाया हैं), तो यह अपनी अंतिम टिप्पणी अवधि में प्रवेश करेगा। यदि आपको कोई बड़ा मुद्दा मिलता है जिसे इस प्रक्रिया में किसी भी बिंदु पर नहीं उठाया गया है, तो कृपया बोलें!

टैग की गई टीम के सदस्य मुझे क्या आदेश दे सकते हैं, इस बारे में जानकारी के लिए

@rfcbot चिंता अवरुद्ध

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

@rfcbot नावों-और-जोश-समय-से-उठाने-किसी भी-चिंताओं को हल करें-वे-हो सकता है-अभी भी-है

अगर यह बिल्कुल मायने रखता है: ज़िग में भी यह सुविधा है ।

5 जनवरी, 2019 09:18:29 पीएसटी पर, मजदक Farrokhzad [email protected] लिखा है:

@rfcbot संकल्प
देना-नाव-और-जोश-समय-से-उठाना-किसी भी-चिंता-वे-हो सकता है-अभी भी-है

हमने पहले ही चिंताओं को उठाया है, और वे "यह भाषा में नहीं होना चाहिए" के बराबर है। वे चिंताएं दूर नहीं हो रही हैं।

मैं एनआरसी की धारणा को पसंद करता हूं कि मैक्रोज़ आईआर उत्पन्न करने में सक्षम होना चाहिए। ऐसा लगता है कि इसके लिए और भविष्य की कई संभावनाओं के लिए एक पूरी तरह से उचित समाधान की तरह लगता है, बिना भाषा के सतही वाक्य-विन्यास को जोड़ने के।

@joshtriplett

हमने पहले ही चिंताओं को उठाया है, और वे "यह भाषा में नहीं होना चाहिए" के बराबर है। वे चिंताएं दूर नहीं हो रही हैं।

स्पष्ट होने के लिए मेरा मतलब उन्हें @rfcbot साथ पंजीकृत करना था क्योंकि प्रस्ताव रद्द होने के बाद बॉट पंजीकृत पुरानी चिंताओं को नहीं देखेगा। मैंने यह चिंता इसलिए उठाई

मैं एनआरसी की धारणा को पसंद करता हूं कि मैक्रोज़ आईआर उत्पन्न करने में सक्षम होना चाहिए। ऐसा लगता है कि इसके लिए और भविष्य की कई संभावनाओं के लिए एक पूरी तरह से उचित समाधान की तरह लगता है, बिना भाषा के सतही वाक्य-विन्यास को जोड़ने के।

मुझे नहीं पता कि यह कैसा दिखेगा या यह एक बेहतर विचार है; यह बल्कि सट्टा लगता है (इस अर्थ में कि "डिजाइन पर सहमत होने में कई साल लग सकते हैं") और break 'label expr कम लागत वाले समाधान की तुलना में अधिक महंगा है जिसमें मैक्रो के परिणाम से परे लाभ भी हैं विस्तार।

_इस मुद्दे के लिए और अन्य सभी के लिए एक प्रक्रिया नोट के रूप में, कृपया प्रस्तावों को आगे-पीछे रद्द करने से बचें... अगर आपको नहीं लगता कि कुछ आगे बढ़ना चाहिए, तो बस उसके लिए चिंताओं का उपयोग करें।_

मैं निश्चित रूप से इससे सहमत हूं। हालांकि, मुझे नहीं लगता कि चिंता यहां उपयुक्त तंत्र है। एक चिंता की तरह लगता है "अगर यह हल हो गया तो मैं स्वीकृति दूंगा"। यहां, मुद्दा यह है कि "यह बिल्कुल आगे नहीं बढ़ना चाहिए, 'विलय' गलत लक्ष्य है, मैं इसके बजाय 'बंद' करना चाहता हूं"। ऐसा लगता है कि "चिंता" के तंत्र द्वारा सबसे अच्छा संभाला नहीं जाता है।

@joshtriplett रुचि के बिंदु के रूप में, क्या आप मुझे उन चिंताओं के बारे में बता सकते हैं जिनका आपने पहले उल्लेख किया था? मैं मूल आरएफसी थ्रेड के माध्यम से चला गया हूं और मुझे यकीन नहीं है कि विशेष रूप से क्या संदर्भित किया जा रहा है। धन्यवाद।

@rfcbot चिंता एर्गोनॉमिक्स और ऑप्टिमाइज़ेशन/प्रदर्शन (कम प्रदर्शन और एर्गोनॉमिक्स का गैर-जंग उदाहरण https://gist.github.com/SoniEx2/fc5d3614614e4e3fe131#file-special-lua)

idk अगर मैं इस अधिकार का उपयोग कर रहा हूँ

(ध्यान दें कि कैसे कुछ "desugaring" (वास्तव में मैं कहूंगा कि यह desugaring के बिल्कुल विपरीत है - goto एक आदिम है, goto में desugar को लूप करता है) काफी भयानक है)

(यह भी ध्यान दें कि लुआ में कुछ भी लेबल नहीं है, इसलिए यह आपको गोटो का उपयोग करने के लिए मजबूर करता है। फिर भी, मेरा मानना ​​​​है कि कम से कम एक ब्रेक-ब्लॉक की आवश्यकता होगी, लेकिन शायद क्लीनर "डिसुगरिंग" के साथ।)

@rfcbot चिंता चाहिए-करीब-नहीं-विलय

(जैसा कि कलह पर @centril द्वारा

मुझे यकीन नहीं है कि यह स्थिरीकरण के पक्ष में या खिलाफ तर्क है, लेकिन ध्यान दें कि आज स्थिर जंग में एन्कोड करना बहुत आसान है:

fn main() {
    'foo: for _ in 0..1 {
        println!("break");
        break 'foo;
        println!("broken");
    }
}

तो एक तरफ, हमें इसे स्थिर करना चाहिए क्योंकि यह मुश्किल से भाषा का विकास कर रहा है, बस for _ in 0..1 को खत्म कर रहा है, दूसरी तरफ हमें इसे स्थिर नहीं करना चाहिए क्योंकि आज इसे करने का एक आसान तरीका है (कब के लिए) यह वास्तव में आवश्यक है) और हमें इस तरह के विरोधी पैटर्न का उपयोग करने के लिए प्रोत्साहित नहीं करना चाहिए।

यह थोड़े भ्रमित करने वाला लगता है और लेबल अनावश्यक है।

ब्रेकिंग ब्लॉक बहुत कम भ्रमित करने वाला है और इसके लिए लेबल की आवश्यकता होती है।

मुझे समझ में नहीं आता क्यों आपको लगता है कि ब्लॉक तोड़ना एक विरोधी पैटर्न है। जो एक्स पर लागू होता है जरूरी नहीं कि वह काफी-एक्स पर भी लागू हो। मैं $299.99 के लिए एक कंप्यूटर खरीदने में सक्षम हो सकता हूं, लेकिन $ 299.98 में नहीं, भले ही वे "मूल रूप से" समान हों।

@nrc

मुझे यकीन नहीं है कि यह स्थिरीकरण के पक्ष में या खिलाफ तर्क है, लेकिन ध्यान दें कि आज स्थिर जंग में एन्कोड करना बहुत आसान है:

    'foo: for _ in 0..1 {
        break 'foo;
    }

तो एक तरफ, हमें इसे केवल स्थिर करना चाहिए क्योंकि यह मुश्किल से भाषा का विकास कर रहा है, बस for _ in 0..1 खत्म कर रहा है,

'a: for _ in 0..1 { break 'a } काम कर सकता है यदि स्पष्ट लक्ष्य किसी को कभी भी 'a: { ... break 'a e; ... } नहीं लिखना है; हालाँकि, इसमें कचरा IR उत्पन्न करने की खामी है कि टाइप चेकर, MIR, और LLVM को इस प्रकार बिगड़ते संकलन समय (कम से कम LBV की तुलना में) को संसाधित करना चाहिए।

दूसरी ओर हमें इसे स्थिर नहीं करना चाहिए क्योंकि आज इसे करने का एक आसान तरीका है (जब यह वास्तव में आवश्यक हो) और हमें इस तरह के विरोधी पैटर्न का उपयोग करने के लिए प्रोत्साहित नहीं करना चाहिए।

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

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

1. 'a: for _ in 0..1 { break 'a }
2. 'a: { ... break 'a e; ... }

ये समान दिख सकते हैं, लेकिन ये बिल्कुल समान नहीं हैं। जबकि पहला यकीनन एक विरोधी पैटर्न है, दूसरा यकीनन नहीं है।

थोड़े loop {} बनाम while true {} (दी गई loop एक मान वापस कर सकता है जबकि while नहीं कर सकता है, लेकिन आइए इसे थोड़ा सा अनदेखा करें)

@nrc हालांकि इसका व्यवहार बिल्कुल समान नहीं है: https://github.com/rust-lang/rust/issues/48594#issuecomment -450246249

विशेष रूप से, break; और continue; का व्यवहार अलग है। इस काल्पनिक कोड पर विचार करें:

some_macro! {
   ...
   break;
   ...
}

यदि some_macro विस्तार 'a { ... } , तो इसका व्यवहार 'a: for _ 0..1 { ... } विस्तृत होने की तुलना में भिन्न होता है।

@ SonyEx2

क्या किसी ने चीजों को धीमे, कम-सहज और कम-एर्गोनोमिक तरीके से फिर से लिखने की कोशिश की है?

कृपया अपनी चिंताओं को अधिक सकारात्मक और उत्पादक तरीके से संप्रेषित करने का प्रयास

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

जिस तरह से मैं चीजों को देखता हूं:

1) यह प्रवाह नियंत्रण के एर्गोनॉमिक्स को नहीं बदलता है। रस्ट में पहले से ही इस तरह के निर्माण मौजूद हैं जैसे 'a: loop { if x { break 'a; } break; } ।

2) यह विशेष रूप से ब्लॉक रिटर्न के एर्गोनॉमिक्स को नहीं बदलता है: लूप पहले से ही मूल्यों को वापस करने में सक्षम हैं।

मेरे लिए, यह रस्ट के पास पहले से मौजूद सुविधाओं के एक सेट के सहज ज्ञान युक्त पूर्णता की तरह लगता है - उन सुविधाओं को सभी (या कम से कम अधिक) ब्लॉकों के लिए सामान्यीकृत करना।

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

क्या कोई मुझे अधिक विशिष्ट शब्दों में समझा सकता है कि क्या समस्याएं मौजूद हैं?

प्रक्रियात्मक रूप से, आईएमओ concern blocking या concern should-close-not-merge -स्टाइल चिंताओं को दर्ज करना उचित नहीं है: यह चिंता प्रस्तावित सुविधा के साथ किसी समस्या को सूचीबद्ध नहीं करती है या कुछ भी जिसे हम हल करने की दिशा में काम कर सकते हैं- - यह सिर्फ एक परमा-अवरोधक है। मुझे नहीं लगता कि rfcbot के सरोकार तंत्र का उपयोग सुविधाओं को परमा-ब्लॉक करने के लिए किया जाना चाहिए, लेकिन केवल चिंताओं के समाधान को ट्रैक करने में मदद करने के लिए और यह सुनिश्चित करने के लिए कि उन्हें उचित रूप से संबोधित/समाधान किया गया है। प्रक्रिया के बारे में मेरी समझ यह थी कि आपकी असहमति को चिह्नित करने के लिए एक अनियंत्रित चेकबॉक्स का उपयोग करने का इरादा था, और उन चिंताओं का उपयोग सुविधा और इसकी कार्यक्षमता के बारे में विशिष्ट, चर्चा-योग्य मुद्दों को दर्ज करने के लिए किया जाना था।

मैं अन्य विशेषताओं पर समान "मुझे यह पसंद नहीं है" चिंताओं को दायर कर सकता था, जिनसे मैं व्यक्तिगत रूप से असहमत था (उदाहरण के लिए वर्दी_पैथ देखें), लेकिन मुझे विश्वास नहीं है कि भाषा डिजाइन करने के लिए अनंत-फिलिबस्टर एक उत्पादक तरीका है।

यदि इस बात के बारे में कोई विशेष चिंता है कि यह सुविधा भाषा के अन्य भागों के साथ इंटरैक्ट करती है जिस पर चर्चा/समाधान किया जाना चाहिए (उदाहरण के लिए "ऐसा लगता है कि इसे try { ... } द्वारा कम किया जा सकता है" या "यह अन- को सक्षम करने में मदद करता है- मुहावरेदार-बड़े कार्य") मुझे लगता है कि उन्हें इस तरह से फाइल करना अधिक उत्पादक होगा।

@Cramertj अगर @Centril ने स्पष्ट रूप से इसका सुझाव नहीं दिया होता तो

"इसे बंद किया जाना चाहिए" के लिए उपयुक्त प्रक्रिया के रूप में आप क्या सुझाव देंगे , यदि किसी ने "क्लोज़" के अलावा किसी अन्य चीज़ के लिए rfcbot के साथ P-FCP दायर किया है? "सुनिश्चित करें कि उन्हें संबोधित / उचित रूप से हल किया गया है" के बराबर लगता है "यह एक दिन स्थिर होने जा रहा है, वहां पहुंचने में क्या लगता है?"। यह प्रवाह में कोई रास्ता नहीं छोड़ता है "इसे कभी स्थिर नहीं किया जाना चाहिए, यह भाषा का हिस्सा नहीं होना चाहिए"।

प्रक्रिया के बारे में मेरी समझ यह थी कि आपकी असहमति को चिह्नित करने के लिए एक अनियंत्रित चेकबॉक्स का उपयोग करने का इरादा था

फिर हमें प्रक्रिया को वापस बदलने की आवश्यकता होगी ताकि आगे बढ़ने के लिए सभी चेकबॉक्स चेक किए जा सकें।

मुझे विश्वास नहीं है कि भाषा डिजाइन करने के लिए अनंत-फिलिबस्टर एक उत्पादक तरीका है।

मुझे विश्वास नहीं है कि यह भी है। मैं इसे समाप्त करने के लिए एक रास्ता खोजना चाहता हूं, मैं बस इसे एक अलग दिशा में समाप्त होते देखना चाहता हूं।

रिकॉर्ड के लिए, इस आरएफसी के साथ अनुभवों के आधार पर, मुझे नहीं लगता कि "हम स्थिरीकरण के दौरान मूल्यांकन/पता कर सकते हैं कि क्या हमें आगे बढ़ना चाहिए" की चेतावनी के साथ एक आरएफसी का जवाब देना एक अच्छा विचार है, क्योंकि यह मुझे स्पष्ट लगता है ऐसा करने से इस तरह के महत्वपूर्ण प्रक्रियात्मक मुद्दे पैदा होते हैं।

हमें कहने के लिए एक पथ की आवश्यकता है "हां, मैं देख सकता हूं कि यह व्यक्तिगत विशेषता भाषा को और अधिक अभिव्यंजक कैसे बनाती है, लेकिन भाषा के समग्र मूल्यांकन के आधार पर, यह अपना वजन नहीं लेता है, और मैं आगे विस्तार नहीं करना चाहता हूं इस तरह भाषा का सतह क्षेत्र"। मेरा मानना ​​​​है कि हमें उस कॉल को नियमित रूप से करने की ज़रूरत है, ऐसा न हो कि हर प्रस्तावित सुविधा को किसी न किसी रूप में अपरिहार्य के रूप में देखा जा सके और केवल आपत्तियों को दूर करने और जारी रखने की बात हो।

मैं वही दोहराऊंगा जो मैंने पहले कहा है क्योंकि ऐसा लगता है कि यह छूट गया है: https://github.com/rust-lang/rust/issues/48594#issuecomment -451795597

मैंने मूल रूप से लूप का उपयोग करने और ब्रेकिंग ब्लॉक का उपयोग करने के बीच के अंतरों के बारे में बात की थी।

मुख्य रूप से, ब्रेकिंग ब्लॉक में अलग-अलग सिंटैक्स होते हैं, (थोड़ा) अलग-अलग शब्दार्थ (बहुत कम से कम बिना लेबल वाले ब्रेक के संबंध में), वे अलग-अलग इरादे और कुछ अन्य छोटी चीजों को दर्शाते हैं।

क्या rfcbot एंटी-चिंता का समर्थन करता है?

@joshtriplett

हमें कहने के लिए एक पथ की आवश्यकता है "हां, मैं देख सकता हूं कि यह व्यक्तिगत विशेषता भाषा को और अधिक अभिव्यंजक कैसे बनाती है, लेकिन भाषा के समग्र मूल्यांकन के आधार पर, यह अपना वजन नहीं लेता है, और मैं आगे विस्तार नहीं करना चाहता हूं इस तरह भाषा का सतह क्षेत्र"। मेरा मानना ​​​​है कि हमें उस कॉल को नियमित रूप से करने की ज़रूरत है, ऐसा न हो कि हर प्रस्तावित सुविधा को किसी न किसी रूप में अपरिहार्य के रूप में देखा जा सके और केवल आपत्तियों को दूर करने और जारी रखने की बात हो।

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

इसी तरह, मुझे पूरा विश्वास है कि मैं व्यक्तिगत रूप से आश्वस्त रहूंगा कि इस सुविधा को विलय कर दिया जाना चाहिए: आईएमओ न केवल विभिन्न उदाहरणों के माध्यम से अपना वजन खींचता है जहां यह सबसे अच्छा/एकमात्र विकल्प है, लेकिन इसके अतिरिक्त भाषा वास्तव में सरल है (चूंकि लेबल किए गए ब्लॉक की अनुमति नहीं देना मेरे लिए आश्चर्यजनक है क्योंकि हम अन्य लेबल वाले निर्माणों को अनुमति देते हैं)।

यदि आप अपनी स्थिति के मेरे उपरोक्त सारांश से सहमत हैं, तो ऐसा लगता है कि हम एक दुर्भाग्यपूर्ण (और, मुझे विश्वास है, ऐतिहासिक!) एक प्रक्रिया की कमी है। एक विकल्प मौजूदा rfcbot नियमों की व्याख्या करना है जैसा कि मैंने ऊपर किया था "कोई चेकबॉक्स आपकी असहमति का संकेत नहीं देता है, बहुमत को खत्म करने के लिए तीन सदस्य आवश्यक हैं", लेकिन मुझे नहीं लगता कि जब वे पेश किए गए थे तो नियमों का मतलब था, इसलिए मुझे लगता है कि यह सुझाव देना मेरे लिए अनुचित था कि आपको इस प्रक्रिया का पालन करना चाहिए (हालाँकि मैंने इसे स्वयं कहीं और किया था)।

मैंने पहले सुझाव सुना है कि हम स्वीकृत-> कार्यान्वित-> स्थिर से जाने वाली सुविधाओं के लिए एक समय सीमा पेश कर सकते हैं, और यह कि हमें उन सुविधाओं को "स्वतः बंद" करना चाहिए जो लगातार बढ़ते बैकलॉग से बचने के प्रयास में पीछे रह जाते हैं। ऐसा कुछ इस मामले को संबोधित कर सकता है, जहां मैं (और, मुझे लगता है, टीम में कई अन्य) चेकबॉक्स को बंद करने के लिए चिह्नित नहीं करेंगे, न ही आप स्वीकार करने के लिए एक चेकबॉक्स चिह्नित करेंगे (मुझे अब भी यह कहते हुए भी डर लगता है कि मैं ' मैं तुम्हें समझाने के लिए एक आखिरी खाई को फेंक रहा हूँ! :मुस्कुराओ :)।

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

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

TL; DR: मुझे लगता है कि हम फंस गए हैं, इसके लिए हमारे पास एक प्रक्रिया होनी चाहिए-- मैं उस बातचीत को कहीं और शुरू करूंगा और इसे यहां लिंक करूंगा। अन्यथा, कृपया टिप्पणी न करें जब तक कि आपके पास महत्वपूर्ण नई जानकारी न हो जिस पर विचार करने की आवश्यकता हो।

@cramertj

यह हमारी वर्तमान प्रक्रिया का एक दुर्भाग्यपूर्ण खतरा है कि किसी सुविधा को स्वीकार या अस्वीकार करने के लिए उपयुक्त टीम की पूर्ण सहमति की आवश्यकता होती है

मैं ईमानदारी से उस एक विशेषता पर विचार करूंगा।

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

मुझे अब भी लगता है कि कई उदाहरण अन्य तरीकों से लिखे जा सकते हैं। यह भाषा में कोई अप्रतिष्ठित अभिव्यंजना नहीं जोड़ता है। मैंने मूल रूप से महसूस किया कि इसे पर्याप्त उदाहरणों से प्रेरित किया जा सकता है, लेकिन जितने अधिक उदाहरण मैं देखता हूं जो इस सुविधा का उपयोग कर सकता है , उतना ही मैं खुद को @withboats से सहमत

(यह भी ध्यान देने योग्य है: @nrc का टोकरा proc-macro-rules जो label_break_value ऐसा लगता है कि इससे बचने के लिए इसे फिर से लिखा गया है।)

एक विकल्प मौजूदा rfcbot नियमों की व्याख्या करना है जैसा कि मैंने ऊपर किया था "कोई चेकबॉक्स आपकी असहमति का संकेत नहीं देता है, बहुमत को खत्म करने के लिए तीन सदस्य आवश्यक हैं", लेकिन मुझे नहीं लगता कि जब वे पेश किए गए थे तो नियमों का मतलब था, इसलिए मुझे लगता है कि यह सुझाव देना मेरे लिए अनुचित था कि आपको इस प्रक्रिया का पालन करना चाहिए (हालाँकि मैंने इसे स्वयं कहीं और किया था)।

मुझे लगता है कि "परहेज करने" के लिए यह सही प्रक्रिया है, लेकिन आपत्ति करने के लिए नहीं।

आईएमओ यह न केवल विभिन्न उदाहरणों के माध्यम से अपना वजन खींचता है जहां यह सबसे अच्छा/एकमात्र विकल्प है, लेकिन भाषा वास्तव में इसके अतिरिक्त के साथ सरल है (चूंकि लेबल वाले ब्लॉक की अनुमति नहीं देना मेरे लिए आश्चर्यजनक है क्योंकि हम अन्य लेबल वाली संरचनाओं की अनुमति देते हैं)।

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

मुझे चिंता है कि लगातार बढ़ती टीमों के साथ हम सुविधाओं पर आम सहमति बनाने की क्षमता खो देंगे, और यह कि भाषा को एक सुसंगत फैशन में चलाना मुश्किल होगा, खासकर लैंग-डिज़ाइन टीम पर।

मुझे सिर्फ स्टीयरिंग की नहीं बल्कि रुकने की चिंता है। एक निश्चित अनिवार्यता है जो कभी-कभी फसल होती है, जहां प्रक्रिया "हां" के पथ को खोजने पर केंद्रित होती है और फ़्लोचार्ट में कोई ग्राफ़ एज नहीं होता है जो "नहीं" की ओर जाता है, बस "अभी तक नहीं"।

भाषा में फीचर वृद्धि के बारे में बात करते हुए 2018 और 2019 में कई पोस्ट लिखी गई हैं, और मुझे लगता है कि भाषा टीम में हमें भाषा के कुल सतह क्षेत्र पर गंभीरता से विचार करने की आवश्यकता है। और मुझे लगता है कि हमारे पास अच्छी प्रक्रियाएं नहीं हैं जो हमें ऐसा करने के लिए प्रोत्साहित करती हैं।

@joshtriplett

यह भाषा में कोई अप्रतिष्ठित अभिव्यंजना नहीं जोड़ता है।

बहुत स्पष्ट होना: यह ठीक यही करता है। वर्तमान में इस कोड को व्यक्त करने का कोई तरीका नहीं है जो अन्य नियंत्रण-प्रवाह निर्माणों में हस्तक्षेप नहीं करता है, जो (जैसा कि अन्य ने बताया है) मैक्रोज़ में विशेष रूप से वांछनीय है, जहां यह एकमात्र ऐसा निर्माण होगा जो गैर-लेबल वाले ब्रेक के माध्यम से लक्षित नहीं है, उपयोगकर्ता द्वारा प्रदत्त break साथ ओवरलैप को जोखिम में डाले बिना मैक्रो-लेखकों को अनुभागों से अलग होने की अनुमति देना।

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

@joshtriplett

मुझे अब भी लगता है कि कई उदाहरणों को अन्य तरीकों से लिखा जा सकता है। यह भाषा में कोई अप्रतिष्ठित अभिव्यंजना नहीं जोड़ता है। मैंने मूल रूप से महसूस किया कि इसे पर्याप्त उदाहरणों से प्रेरित किया जा सकता है, लेकिन जितने अधिक उदाहरण मैं देखता हूं कि _could_ इस सुविधा का उपयोग करता है, उतना ही मैं खुद को @withboats से सहमत

क्या ऐसा कुछ है जिसे हम शायद खोद सकते हैं?

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

तर्क की यह पंक्ति मुझे अजीब लगती है (जब तक कि आप किसी संस्करण के साथ लेबल किए गए लूप ब्रेक को हटाना नहीं चाहते)। आप जो चाहते हैं वह भाषा में नहीं था, इसके आधार पर डिजाइन निर्णयों को आधार बनाना उचित नहीं लगता। यह वहाँ है, और इसलिए हमें इस पर विचार करना चाहिए कि क्या यह जोड़ उसके साथ सुसंगत है। नहीं तो कई चीजें हैं जो मैंने रस्ट के बारे में अलग तरीके से की होंगी, लेकिन मुझे ऐसा नहीं करना चाहिए और न ही करना चाहिए।

मुझे न केवल स्टीयरिंग की चिंता है बल्कि _stopping_ की भी चिंता है। एक निश्चित अनिवार्यता है जो कभी-कभी फसल होती है, जहां प्रक्रिया "हां" के पथ को खोजने पर केंद्रित होती है और फ़्लोचार्ट में कोई ग्राफ़ एज नहीं होता है जो "नहीं" की ओर जाता है, बस "अभी तक नहीं"।

अभी तक "नहीं" का अपना रूप इस अर्थ में नहीं है कि यह हाँ के बिना स्थिर नहीं होगा। इसके अलावा, कोई नहीं है: हममें से बाकी लोगों को समझाएं कि एलबीवी एक बुरा विचार है/एक्स, वाई, और जेड कारणों से पर्याप्त रूप से प्रेरित नहीं है। मुझे अभी तक ऐसे कई ठोस तर्क सुनने को नहीं मिले हैं। आपने यहाँ भी स्पष्ट रूप से प्रदर्शित किया है कि कोई अनिवार्यता नहीं है।

भाषा में फीचर वृद्धि के बारे में बात करते हुए 2018 और 2019 में कई पोस्ट लिखे गए हैं, और मुझे लगता है कि भाषा टीम में हमें भाषा के कुल सतह क्षेत्र पर _गंभीर_ विचार करने की आवश्यकता है। और मुझे लगता है कि हमारे पास अच्छी प्रक्रियाएं नहीं हैं जो हमें ऐसा करने के लिए प्रोत्साहित करती हैं।

मैं व्यक्तिगत रूप से महसूस इन पदों की है कि कई के बारे में या तो कर रहे हैं स्थिरता (लेकिन जैसा कि जिसे उपयुक्त शब्दों में नहीं के रूप में @nikomatsakis किया ...) या यह है कि कई लोगों को समझ में नहीं आता कि कैसे भाषा टीम संचालित (यानी हम पहले से ही कुल के लिए गंभीर विचार देते हैं सतह क्षेत्रफल)। रस्ट का कुल सतही सिंटैक्स वास्तव में पिछले वर्ष की तुलना में वास्तव में सिकुड़ा है, विकसित नहीं हुआ है। एलबीवी उस विशेष रूप से वृद्धि नहीं करता है और एक तर्क दिया जा सकता है कि यह वास्तव में भाषा में प्रस्तुतियों की संख्या को कम करता है और वाक्यविन्यास को अधिक समान बनाता है।

केवल व्याकरण की प्रस्तुतियों के संयोजन से भाषा का सतह क्षेत्र सिकुड़ नहीं जाता है।

सशर्त शाखाओं की संख्या को कम करने से भाषा के सतह क्षेत्र को तर्कसंगत रूप से कम किया जा सकता है।

मुझे नहीं लगता कि यह विशेष सुविधा किसी भी तरह से जाती है, जैसे कि यह शायद तटस्थ है। लेकिन जैसे चीजें हैं जो यूनिफाई भाषा निर्माणों (bool करते हैं, किसी को भी?) सतह क्षेत्र हटना है।

इसके लायक क्या है, कॉमन लिस्प, जो इस अर्थ में जंग के समान है कि यह मैक्रोज़ के साथ एक बहु-प्रतिमान भाषा है, में यह सुविधा है (नाम block / return-from )। जैसा कि यहां चर्चा की गई है, कॉमन लिस्प में मैक्रोज़ लिखते समय और इरेड्यूसिबल रूप से जटिल नियंत्रण प्रवाह को व्यक्त करने में यह निर्माण अक्सर सहायक होता है।

(block foo
  (return-from foo "value"))

मेरी समझ में यह है कि आम लिस्प में इस सुविधा को सफल माना जाता है। यह उन विशेषताओं के बारे में बातचीत में नहीं आता है जो भाषा को सीखना या लागू करना मुश्किल बनाते हैं।

समावेश है

early return from block ⊂ exceptions ⊂ call/cc

उदाहरण के लिए, योजना में return-from का निम्नलिखित अनुकरण संभव है:

(define call/cc call-with-current-continuation)

(define-syntax block
    (syntax-rules ()
        ((_ label statements ...)
            (call/cc (lambda (label) (begin statements ...))))))

(block foo
    (display "Visible text")
    (foo "value")
    (display "Phantom text"))

योजना में, call/cc को विवादास्पद के रूप में सफल माना जाता है। मुझे यह विशेष रूप से दिलचस्प लगता है क्योंकि इसके बारे में बात करने में सक्षम होने के लिए आपको पहले एक वस्तु तैयार करनी होगी। यहां तक ​​कि अगर आप call/cc को एक गलत विशेषता मानते हैं, तो भी इसने भाषा को बौद्धिक अर्थों में अधिक महत्वपूर्ण बना दिया है।

नेमेरले भाषा में नामांकित ब्लॉक कार्यक्षमता है।
यह बहुत उपयोगी और सुविधाजनक है।

वापसी, विराम और जारी रखना इस सुविधा का उपयोग करके मैक्रोज़ के रूप में कार्यान्वित किया जाता है।

@jhpratt कृपया अंक में चर्चा पढ़ें।

मैंने @Centril के सुझाव पर IRLO पर की दोहराते हुए कहा:

इस सुविधा पर चर्चा करते हुए, मैंने निम्नलिखित प्रेरणा का सुझाव दिया (सामान्य लूप-संबंधित संस्करण के विपरीत):

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

इसके लिए उपरोक्त मेरा प्राथमिक उपयोग-मामला है: मुझे प्रारंभिक-वापसी शैली पसंद है। try {} ब्लॉक हमें वहां सबसे ज्यादा पहुंचाते हैं, लेकिन, फिर से, वे वास्तव में लेबल का समर्थन नहीं करते हैं (ऐसा नहीं है कि आपको इसकी आवश्यकता है, क्योंकि आप नेस्टेड ब्लॉक के लिए try {}? लिखेंगे) और बनाएं आप अपने प्रकार को एक निश्चित मोनैडिक आकार में शूहॉर्न करते हैं जो कि कैचल नहीं है (जैसा कि प्रदान किए गए उपयोग-मामलों से प्रमाणित है)।

मैंने सी ++ के बारे में कुछ अवलोकन भी किए, जहां लेबल ब्रेक/जारी नहीं होना बहुत दर्दनाक है, खासकर जंग-जैसे इटरेटर्स की अनुपस्थिति में। उदाहरण के लिए, आंतरिक लूप के बाहर संभावित-UB goto या स्थानीय break प्लस एक सशर्त continue बिना बाहरी लूप को जारी रखने का कोई तरीका नहीं है।

कम से कम सेल्सियस पर ++ एक उधार-चेकर की कमी इनलाइन लैम्ब्डा चाल कम दर्दनाक है, जो करता है, प्रभावी ढंग से, समर्थन LVB, इनलाइन लैम्ब्डा में लौटने के बाद से LLVM के inliner द्वारा LVB की तरह कुछ में बदल जाता है बनाता है। कुछ इस तरह है... रस्ट में कुछ ज्यादा ही संदिग्ध।

मुझे यह भी इंगित करना चाहिए कि यह सुविधा गो के goto की अभिव्यक्ति में लगभग बराबर है, जो संकलन-समय घोषणाओं पर कूद नहीं रहा है और क्या नहीं (स्पष्ट रूप से, अगर रॉब पाइक ने सोचा goto स्वीकार्य था, दिया गया सी ++ की समस्याओं को कम करने की कोशिश करने का इतिहास, मैं उस पर कुछ हद तक भरोसा करता हूं)।

इसके अलावा, अगर हम पूर्व कला में जाने जा रहे हैं, तो कोटलिन यह सटीक सुविधा भी प्रदान करता है, return<strong i="24">@label</strong> expr; ।

c'ish भाषाओं में मैं अक्सर लेबल का उपयोग करता हूं, यहां तक ​​कि बिना किसी आने वाले गोटो के भी, लूप के तहत स्थिर ब्रेकप्वाइंट के लिए स्थानों के रूप में, क्योंकि डीबगर पहचान सकता है break function:label ।
ब्रेक पर आम सहमति के बिना भी, लेबल अच्छे हो सकते हैं।

संपादित करें: एक संभावित बाधा यह है कि आम तौर पर लेबल प्रतीक नामकरण सम्मेलन का पालन करते हैं, अगर मैं आरएफसी को समझता हूं, तो ये लेबल प्रतीक नामकरण सम्मेलन का पालन नहीं करते हैं जहां ', प्रतीक नाम में मान्य नहीं है।
मुझे यकीन नहीं है कि उदाहरण के लिए बौना, या जीडीबी स्वयं ही है, अगर वास्तव में यहां कोई समस्या है।

संपादित करें2:
बहुत यकीन है कि इसमें कुछ धुआं है, अगर हम सामान्य सी आधारित लेबल के उद्धरण व्यवहार को देखते हैं,
डीबगर में, जीडीबी कम से कम प्रतीक नाम के हिस्से के बजाय उद्धरण के लिए उद्धरणों का इलाज करने जा रहा है। निम्नलिखित परिणाम

0x401114 पर ब्रेकप्वाइंट 1: फ़ाइल, पंक्ति 1।
बेजोड़ बोली

echo "void main() { } void hmm() { umm: return; }" | gcc -g -x c -;
gdb -ex "b hmm:'umm'" -ex "b hmm:'umm" -batch ./a.out

और मुझे विश्वास नहीं है कि यह जीडीबी में जंग-भाषा भाषा विशिष्ट समर्थन से प्रभावित होने में सक्षम है, क्योंकि मेरा मानना ​​​​है कि यह उद्धरण प्रतीक मिलान से पहले होता है।

संपादित करें: मौजूदा लूप लेबल के कारण जहाज शायद इस पर रवाना हो गया है।

ब्लॉक से जल्दी वापसी के पक्ष में एक छोटी सी बात गरीब आदमी की अनुबंध प्रोग्रामिंग होगी। एक बस पूर्व और बाद की शर्तों के रूप में मुखर बयान जोड़ता है। आराम बनाए रखने के लिए, इस निर्माण की अनुमति देने के लिए return को break 'ret से बदलना संभव होना चाहिए:

let value = 'ret: {
    // ...
};
assert!(postcondition(value));
return value;

हालांकि, यह एक अपूर्ण समाधान है, क्योंकि ब्लॉक के अंदर return को प्रतिबंधित किया जाना चाहिए।

एक नोट जोड़ना कि मुझे यह सुविधा चाहिए थी, लेकिन इसका उपयोग नहीं किया क्योंकि मुझे नहीं पता था कि यह अस्तित्व में है, जो मुझे लगता है कि "लोग इसे नहीं चाहते हैं, जैसा कि इसका सबूत है कि कितने लोग इसका उपयोग करते हैं" पर एक नकारात्मक संशोधक है।

मैंने आज सुबह स्वतंत्र

मैं आज इसके साथ खेल रहा हूं, और यह async ब्लॉक में _super_ काम में आता है। हालांकि, यह try_blocks सुविधा के साथ संयुक्त होने पर समस्याओं में भाग लेने लगता है:

#![feature(try_blocks, label_break_value)]

fn main() {
    let _: Result<(), ()> = try {
        'foo: {
            Err(())?;
            break 'foo;
        }
    };
}

error[E0695]: unlabeled `break` inside of a labeled block
 --> src/main.rs:6:20
  |
6 |             Err(())?;
  |                    ^ `break` statements that would diverge to or through a labeled block need to bear a label

error: aborting due to previous error

कोशिश ब्लॉक एक गलती है।

... क्या आप ? ही लेबल नहीं कर सकते? (जैसा कि Err(()) 'foo?; )

मैं दृढ़ता से असहमत हूं कि कोशिश ब्लॉक एक गलती है, हालांकि यह एक अलग चर्चा है, और शायद यहां आगे और आगे जाने के लायक नहीं है।

इस विशेष उदाहरण में यह संभव हो सकता है, लेकिन मेरे पास वास्तविक कोड की तुलना में यह बहुत कम है, जहां 'foo में कोड का एक अच्छा हिस्सा है, और कई ? s हैं।

@ SonyEx2

कोशिश ब्लॉक एक गलती है।

यह टिप्पणी अनुचित है। @jonhoo की टिप्पणी एक (संभवतः) छोटी गाड़ी बातचीत की रिपोर्ट कर रही थी। try ब्लॉक (या लेबल-ब्रेक-वैल्यू) के बारे में किसी की राय के बावजूद यह स्पष्ट है कि उन्हें सुचारू रूप से इंटरऑपरेट करना चाहिए।

उन्हें Err(()) 'foo?; सिंटैक्स के साथ होना चाहिए।

@jonhoo मुझे संदेह है कि आप देख रहे हैं कि try कैसे डिसुगर किया गया है - क्या आप इसे एक अलग मुद्दे के रूप में दर्ज कर सकते हैं और हम वहां संभावित सुधारों की चर्चा को आगे बढ़ा सकते हैं?

RFC का कहना है कि

'BLOCK_LABEL: { EXPR }

वाक्यात्मक चीनी के लिए है

'BLOCK_LABEL: loop { break { EXPR } }

मैंने उस प्रतिस्थापन को बनाने की कोशिश की, और कोड संकलित करने योग्य कोड के बारे में चेतावनी के साथ संकलित करता है।

#![feature(try_blocks, label_break_value)]

fn main() {
    let _: Result<(), ()> = try {
        'foo: loop {
            break {
                Err(())?;
                break 'foo;
            }
        }
    };
}

@nikomatsakis @ciphergoth ने https://github.com/rust-lang/rust/issues/72483 के रूप में दायर किया

मुझे लगता है कि अब मुझे इस पर कोई आपत्ति नहीं है। मैं लेबल ब्रेक की प्रारंभिक अवधारणा पर अधिक दृढ़ता से विरोध करता अगर यह आज विचार के लिए होता, लेकिन यह देखते हुए कि यह अवधारणा मौजूद है, मुझे नहीं लगता कि यह मेरे लिए मनमाने ढंग से ब्लॉक के लिए इसके आवेदन पर आपत्ति जारी रखने के लिए समझ में आता है।

(यह मौजूदा फॉर्म पर लागू होता है, break का उपयोग करते हुए, किसी अन्य सिंटैक्स के लिए नहीं।)

@rfcbot समाधान चाहिए-करीब-न-विलय
@rfcbot ने समीक्षा की

@joshtriplett इसके लायक क्या है, मैंने इसे async ब्लॉक में बेहद उपयोगी पाया है, क्योंकि यह "जल्दी वापसी" करने का एकमात्र तरीका है। इसका मतलब है कि लिखने के बजाय:

async {
  // do thing a
  if thing_a_failed {
    // handle specially (note, _not_ ?)
  } else {
    // do thing b
    if thing_b_failed {
      // handle specially (note, _not_ ?)
    } else {
      // do thing c, etc..
    }
  }
}

मैं लिख सकता हूँ:

async {
  'block {
  // do thing a
  if thing_a_failed {
    // handle specially (note, _not_ ?)
    break 'block;
  }

  // do thing b
  if thing_b_failed {
    // handle specially (note, _not_ ?)
    break 'block;
  }

  // do thing c, etc..
  }
}

यह बड़े करीने से समान है कि आप return साथ फ़ंक्शंस/क्लोज़र में और लूप्स में continue/break साथ जल्दी-वापसी कैसे कर सकते हैं। बेशक यह अच्छा होगा अगर मुझे अतिरिक्त ब्लॉक ( async 'block { एक संभावना?) की आवश्यकता नहीं है, लेकिन यह निश्चित रूप से नेस्टेड if-s को हरा देता है।

async ब्लॉक को सीधे लेबल के साथ एनोटेट करने की अनुमति देना इस सुविधा के लिए एक बहुत अच्छा एक्सटेंशन लगता है।

@rfcbot FCP रद्द करें

मैं रद्द करने जा रहा हूँ FCP यहाँ के रूप में यह हमेशा के लिए अवरुद्ध कर दिया गया है. हमें शायद इस बात पर चर्चा करनी चाहिए कि क्या हम इस भविष्य को आगे बढ़ाना चाहते हैं। यदि और कुछ नहीं है, तो ऐसा लगता है कि इसे async ब्लॉक को ध्यान में रखते हुए अपडेट किया जाना चाहिए, और ऐसा लगता है कि यह सुविधा के लिए एक नया उपयोग केस जोड़ता है।

@nikomatsakis प्रस्ताव रद्द कर दिया गया।

ध्यान दें कि async ब्लॉक की उपस्थिति में इस प्रस्ताव के शब्दार्थ के बारे में कोई अस्पष्टता नहीं है: RFC में परिभाषा अभी भी लागू होती है अर्थात

'BLOCK_LABEL: { EXPR }

बस वाक्यात्मक चीनी के लिए है

'BLOCK_LABEL: loop { break { EXPR } }

सिवाय इसके कि बिना लेबल वाला ब्रेक या जारी रहता है जो अंतर्निहित लूप से जुड़ जाएगा EXPR के अंदर वर्जित है।

ध्यान दें कि आप (प्रारंभिक) return async ब्लॉक से break लेबल के बजाय कर सकते हैं, return async ब्लॉक को लेबल करने का कोई मतलब नहीं है:

let fut = async {
    return 42;
    0
};

println!("{}", fut.await); // prints 42

( खेल का मैदान )

@WaffleLapkin मैं वास्तव में यहाँ सिर्फ यह ध्यान देने के लिए आया था कि जैसा कि मुझे बारे में सूचित किया गया था ! मुझे लगता है कि यह सुविधा अभी भी कोड के _skip_ अनुभागों में सक्षम होने के लिए बहुत उपयोगी है (इस ब्लॉक के बाकी हिस्सों को न चलाएं, लेकिन वापस न आएं), लेकिन async _specifically_ के लिए इसकी प्रयोज्यता इससे कम है मैंने शुरू में सोचा था।