साथ में आरएफसी लेबल रिटर्न / ब्रेक के आधार पर एक अवरोह पर चर्चा करता है, क्या हम भी ऐसा कर रहे हैं या बस ? और catch संकलक में होगा?

संपादित करें: मुझे लगता है कि लेबल रिटर्न / ब्रेक ? और catch से अलग एक उत्कृष्ट विचार है, इसलिए यदि उत्तर नहीं है तो मैं शायद इसके लिए एक अलग RFC खोलूंगा।

स्पष्ट उद्देश्यों के लिए लेबल किया गया रिटर्न / ब्रेक विशुद्ध रूप से है।

शुक्र, 5 फरवरी, 2016 को अपराह्न 3:56 बजे, जोनाथन रीम सूचनाएँ @ithub.com
लिखा था:

साथ में आरएफसी लेबल रिटर्न / ब्रेक के आधार पर एक अवरोह पर चर्चा करता है,
क्या हम भी ऐसा कर रहे हैं या सिर्फ इसके लिए विशेष उपचार होगा? तथा
संकलक में पकड़?

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/rust-lang/rust/issues/31436#issuecomment -180551605।

एक और अनसुलझे सवाल जिसे हमें स्थिर करने से पहले हल करना है कि वह कौन सा अनुबंध है जो impl s Into का होना चाहिए - या Into का उपयोग करने के लिए सही विशेषता भी है यहाँ त्रुटि-अपकास्टिंग के लिए। (शायद यह एक और चेकलिस्ट आइटम होना चाहिए?)

@reem

मुझे लगता है कि लेबल वापसी / ब्रेक एक उत्कृष्ट विचार है ... मैं शायद इसके लिए एक अलग आरएफसी खोलूंगा।

कृपया कीजिए!

Carrier विशेषता के विषय पर, यहाँ इस तरह के एक लक्षण का उदाहरण दिया गया है जिसे मैंने RFC प्रक्रिया में जल्दी लिखा था।
https://gist.github.com/thepowersgang/f0de63db1746114266d3

पार्सिंग के दौरान इसका इलाज कैसे किया जाता है?

struct catch {
    a: u8
}

fn main() {

    let b = 10;
    catch { a: b } // struct literal or catch expression with type ascription inside?

}

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

भी

let c1 = catch { a: 10 };
let c2 = catch { ..c1 }; // <--

struct catch {}
let c3 = catch {}; // <--

+ https://github.com/rust-lang/rfcs/issues/306 if (जब!) लागू किया गया।
ऐसा लगता है कि संरचनात्मक शाब्दिक के अलावा कोई संघर्ष नहीं है।

ऊपर दिए गए उदाहरणों को देखते हुए मैं सबसे सरल समाधान (हमेशा की तरह) के लिए हूं - हमेशा catch { को अभिव्यक्ति पदों में catch ब्लॉक के रूप में व्यवहार करता हूं। कोई भी उनकी संरचना को catch वैसे भी नहीं कहता है।

यदि catch बजाय किसी कीवर्ड का उपयोग किया गया तो यह आसान होगा।

यह कीवर्ड सूची है: http://doc.rust-lang.org/nightly/grammar.html#keywords

@bluss हाँ, मैं मानता हूं कि उनमें से कोई भी महान नहीं है ... override केवल एक ही है जो करीब है। या हम do उपयोग कर सकते हैं, हेह। या एक संयोजन, हालांकि मैं किसी भी महान लोगों को तुरंत नहीं देखता हूं। do catch ?

do केवल एक ही है जो IMO के करीब लगता है। उपसर्ग के रूप में do एक कीवर्ड सूप थोड़ा अनियमित है, जो भाषा के किसी अन्य भाग के समान नहीं है? क्या while let एक कीवर्ड सूप भी है? उस एक को अब ठीक लगता है, जब आपको उसकी आदत होती है।

पोर्ट try! उपयोग करने के लिए ?

क्या इसके बजाय ? का उपयोग करने के लिए try! पोर्ट किया जा सकता है? यह उपयोग के मामले के लिए अनुमति देगा जहाँ आप डिबगिंग करते समय Result वापसी का मार्ग प्राप्त करना चाहते हैं। try! यह काफी आसान है, आप फ़ाइल की शुरुआत में मैक्रो को ओवरराइड कर सकते हैं (या lib / main.rs में):

macro_rules! try {
    ($expr:expr) => (match $expr {
        Result::Ok(val) => val,
        Result::Err(err) => {
            panic!("Error occured: {:?}", err)
        }
    })
}

आपको try! Result वापसी पथ की पहली घटना से शुरू होने वाला पैनिक स्टैक ट्रेस मिलेगा। वास्तव में, यदि आप try!(Err(sth)) बजाय एक त्रुटि खोजने पर return Err(sth) , तो आपको पूर्ण स्टैक ट्रेस भी मिलता है।

लेकिन जब लोगों ने उस चाल को लागू नहीं किया है, जो विदेशी पुस्तकालयों को डीबग कर रहा है, तो कोई श्रृंखला में try! उपयोग पर निर्भर करता है। और अब, यदि लाइब्रेरी हार्डकोडेड व्यवहार के साथ ? ऑपरेटर का उपयोग करती है, तो स्टैकट्रेस मिलना लगभग असंभव हो जाता है।

अगर try! ओवरराइड करना अच्छा होगा तो ? ऑपरेटर को भी प्रभावित करेगा।

बाद में जब मैक्रो सिस्टम को अधिक सुविधाएँ मिलती हैं तो आप घबरा सकते हैं! केवल विशिष्ट प्रकारों के लिए।

यदि इस प्रस्ताव के लिए RFC की आवश्यकता है तो कृपया मुझे बताएं।

आदर्श रूप से ? को स्टैक ट्रेस समर्थन प्रदान करने के लिए सीधे बढ़ाया जा सकता है, बजाय try! को ओवरराइड करने की क्षमता पर भरोसा करने के। तब यह हर जगह काम करेगा।

स्टैक के निशान सिर्फ एक उदाहरण हैं (हालांकि एक बहुत उपयोगी है, मुझे लगता है)।
यदि कैरियर विशेषता को काम करने के लिए बनाया गया है, तो हो सकता है कि इस तरह के एक्सटेंशन को कवर किया जा सके?

सूर्य पर, 7 फरवरी, 2016 को 4:14 बजे, रसेल जॉन्सटन सूचनाएं @github.com
लिखा था:

आदर्श रूप में? बस स्टैक ट्रेस समर्थन सीधे प्रदान करने के लिए बढ़ाया जा सकता है,
ओवरराइड करने की क्षमता पर भरोसा करने के बजाय कोशिश करो!। तब यह काम करेगा
हर जगह।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/rust-lang/rust/issues/31436#issuecomment -181118499।

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

उस सामान्य मामले पर विचार करें जहां किसी के पास कुछ Result<V,E> मूल्य लौटाने वाला कोड हो। अब हमें सह-अस्तित्व के लिए Carrier विशेषता के कई कार्यान्वयनों के लिए अनुमति देने की आवश्यकता होगी। E0119 में नहीं चलने के लिए, किसी को सभी कार्यान्वयन को दायरे से बाहर करना होगा (संभवतः विभिन्न लक्षणों के माध्यम से, जो डिफ़ॉल्ट रूप से आयात नहीं किए जाते हैं), और जब ? ऑपरेटर का उपयोग करते हैं, तो उपयोगकर्ता को वांछित आयात करने की आवश्यकता होती है कार्यान्वयन।

यह हर किसी की आवश्यकता होगी, यहां तक ​​कि जो लोग डिबग नहीं करना चाहते हैं, वे ? का उपयोग करते समय अपने वांछित विशेषता कार्यान्वयन को आयात करने के लिए, पूर्वनिर्धारित डिफ़ॉल्ट के लिए कोई विकल्प नहीं होगा।

संभवतः E0117 भी एक मुद्दा हो सकता है, अगर Carrier Result<V,E> Carrier सबसे अधिक उपयोग किए जाने वाले मामलों (तुच्छ कार्यान्वयन, और panic! आईएनजी कार्यान्वयन, शायद अधिक) के साथ Carrier विशेषता।

एक मैक्रो के माध्यम से ओवरराइड करने की संभावना होने से मूल कार्यान्वयनकर्ता पर अतिरिक्त बोझ के बिना एक बड़ा लचीलापन प्रदान करेगा (उन्हें अपने वांछित कार्यान्वयन को आयात करने की आवश्यकता नहीं है)। लेकिन मैं यह भी देखता हूं कि जंग में पहले कभी स्थूल आधारित ऑपरेटर नहीं था, और यह कि ? को स्थूल के माध्यम से लागू करना संभव नहीं है यदि catch { ... } को काम करने के लिए माना जाता है, कम से कम अतिरिक्त भाषा आइटम के बिना नहीं ( return_to_catch , throw , break को RFC 243 में उपयोग के रूप में लेबल किया गया)।

मैं किसी भी सेटअप के साथ ठीक हूं, जो एक Err Result 3.75% प्राप्त करने में सक्षम करता है, जबकि केवल फ़ाइल के शीर्ष पर, कोड की एक बहुत छोटी राशि को संशोधित करने के लिए। समाधान को यह भी असंबंधित कार्य करना चाहिए कि Err प्रकार कैसे और कहाँ कार्यान्वित किया जाता है।

बस बिकने में झंकार करने के लिए: catch in { ... } बहुत अच्छी तरह से बहती है।

catch! { ... } एक और बैककॉम्प पसंद है।

इसके अलावा, ऐसा नहीं है कि मैं कुछ भी बदलने की उम्मीद करता हूं, लेकिन यह ध्यान दें कि यह मल्टी-आर्म मैक्रोज़ को तोड़ने वाला है, जो $i:ident ? को स्वीकार कर रहे थे, उसी तरह से टाइप एसेसमेंट ने $i:ident : $t:ty तोड़ दिए।

पीछे की संगतता को ज़्यादा मत करो, बस catch को एक कीवर्ड के रूप में मानो जब { (संभवतः केवल अभिव्यक्ति की स्थिति में हो, लेकिन मुझे यकीन नहीं है कि अगर यह बहुत अनुकूलता बदलता है)।

मैं कुछ संभावित समस्याओं की भी कल्पना कर सकता हूं जिसमें संरचना संबंधी शाब्दिक (जैसे let catch = true; if catch {} ) शामिल नहीं हैं; लेकिन मैं एक और अधिक बदसूरत सिंटैक्स पर एक मामूली ब्रेकिंग परिवर्तन पसंद करता हूं।

क्या हमारे पास नए खोजशब्द, वैसे भी जोड़ने के लिए नहीं है? हम नए सिंटैक्स के लिए किसी तरह के from __future__ ऑप्ट-इन की पेशकश कर सकते हैं; या कमांड-लाइन / Cargo.toml पर एक जंग भाषा संस्करण संख्या निर्दिष्ट करें।
मुझे बहुत संदेह है कि लंबी अवधि में, हम केवल उन्हीं कीवर्ड के साथ काम कर पाएंगे, जो पहले से आरक्षित हैं। हम नहीं चाहते कि हमारे कीवर्ड संदर्भ के आधार पर प्रत्येक के तीन अलग-अलग अर्थ हों।

मैं सहमत हूँ। यह पहला RFC भी नहीं है जहाँ यह आया है (https://github.com/rust-lang/rfcs/pull/1444 एक और उदाहरण है)। मुझे उम्मीद है कि यह अंतिम नहीं होगा। (इसके अलावा default https://github.com/rust-lang/rfcs/pull/1210 से, हालांकि यह एक RFC नहीं है जिसका मैं पक्ष में हूं।) मुझे लगता है कि हमें जोड़ने का एक तरीका खोजने की आवश्यकता है। ईमानदार-से-देव खोजशब्दों के बजाय हर नए मामले के लिए व्याकरण हैक करने के लिए कैसे पता लगाने की कोशिश कर रहा है।

1.0 से पहले कई कीवर्ड्स न जमा करने का पूरा तर्क नहीं था कि हम निश्चित रूप से नए कीवर्ड्स को भाषा में पीछे की ओर जोड़ने के लिए एक तरीका शुरू कर सकते हैं (संभवतः स्पष्ट रूप से चुनने के द्वारा), तो कोई मतलब नहीं था? लगता है कि अब एक अच्छा समय होगा।

@ जापरिक क्या आप अपने पुराने पीआर को पुनर्जीवित करने और इस पर लेने में रुचि रखते हैं?

@ न्यूटन मेरे कार्यान्वयन ने foo? को उसी तरह से try!(foo) रूप में उतारा। यह भी केवल मेथड और फंक्शन कॉल पर काम करता है, अर्थात foo.bar()? और baz()? कार्य लेकिन quux? और (quux)? नहीं। प्रारंभिक कार्यान्वयन के लिए क्या यह ठीक होगा?

@japaric इसे विधियों और फ़ंक्शन कॉल तक सीमित

इसे तरीकों और फ़ंक्शन कॉल तक सीमित रखने का क्या कारण था?

? विस्तार का परीक्षण करने का सबसे आसान तरीका (मेरे लिए)

क्या यह सामान्य पोस्टफ़िक्स ऑपरेटर के रूप में आसान नहीं होगा?

शायद

@japaric यह संभव है कि इसे एक पूर्ण पोस्टफ़िक्स ऑपरेटर के रूप में सामान्यीकृत किया जाए (जैसा कि ? सरल डिसुगरिंग के साथ ठीक है और फिर catch बाद में जोड़ें।

@ न्यूटन ठीक है, मैं अगले सप्ताह तक पोस्टफिक्स संस्करण में

# 31954 :-) में मेरे पीआर को बगावत / अद्यतन

स्टैक के निशान प्रदान करने के लिए समर्थन के बारे में क्या? क्या वह योजनाबद्ध है?

मुझे +1 आदमी होने से नफरत है, लेकिन स्टैक के निशान ने अतीत में मेरे समय के अच्छे हिस्से को बचा लिया है। शायद डिबग पर बनाता है, और जब त्रुटि पथ मार,? ऑपरेटर फ़ाइल / लाइन को वीईसी के परिणाम में संलग्न कर सकता है? हो सकता है कि Vec केवल डिबग हो सकता है?

और वह या तो उजागर हो सकता है या त्रुटि विवरण के हिस्से में बदल सकता है ...

मैं उस स्थिति में भागता रहता हूं, जहां मैं try! / ? का उपयोग करना चाहता हूँ, पुनरावृत्तियों के अंदर Option<Result<T, E>> लौट रहे हैं। दुर्भाग्य से जो वर्तमान में वास्तव में काम नहीं करता है। मुझे आश्चर्य है कि अगर वाहक विशेषता को इस का समर्थन करने के लिए अतिभारित किया जा सकता है या इसके बजाय एक अधिक सामान्य From जाएगा?

@hexsel मैं वास्तव में Result<> प्रकार के डिबग में निर्देश बिंदुओं का एक वीसी ले जाऊंगा ? यह करने के लिए संलग्न होगा। इस तरह से DWARF जानकारी का उपयोग पठनीय स्टैकट्रेस के निर्माण के लिए किया जा सकता है।

@mitsuhiko लेकिन आप कैसे बना सकते हैं और पैटर्न-मैच Result ? यह _just_ a enum atm है।

Option रैपिंग के लिए, मेरा मानना ​​है कि आप Some(catch {...}) ।

वर्तमान में, मेरी आदत अभी क्या करना है try!(Err(bla)) के बजाय return Err() , ताकि मैं एक के साथ पर बाद में कोशिश मैक्रो ओवरराइड कर सकते हैं कि घबरा, आदेश में एक नामों को प्राप्त करने में। यह मेरे लिए अच्छी तरह से काम करता है, लेकिन मैं जिस कोड से निपटता हूं वह बहुत निम्न स्तर का है, और ज्यादातर त्रुटियों की उत्पत्ति करता है। मैं अभी भी से बचने के लिए होगा ? अगर मैं बाह्य कोड है कि रिटर्न का उपयोग Result ।

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

@mitsuhiko मैं Error विशेषता और TLS पर एक नई (डिफ़ॉल्ट) विधि के बारे में सोच सकता हूं।
बाद का उपयोग सैनिटाइज़र द्वारा कभी-कभी किया जाता है।

@eddyb जो केवल तभी काम करता है, जब परिणाम की पहचान की जा सकती है और इसके लिए उसे बॉक्सिंग करने की आवश्यकता होती है या यह मेमोरी में घूम जाएगा क्योंकि यह स्टैक के ऊपर से गुजरता है।

@mitsuhiko TLS? वास्तव में नहीं, आपको केवल त्रुटि के आधार पर मूल्य की तुलना करने में सक्षम होना चाहिए।

या यहां तक ​​कि सिर्फ प्रकार ( From इनपुट और आउटपुट को जोड़ने के साथ), आप कितनी समवर्ती त्रुटियों से स्टैकट्रैक चाहते हैं, कभी भी एक साथ प्रचारित करना होगा?

जब व्यक्तिगत रूप से सरल समाधान काम करते हैं, तो मैं Result -संकलक हैक्स को जोड़ने के खिलाफ हूं।

@eddyb त्रुटि स्टैक के ऊपर से गुजरती है। आप जो चाहते हैं वह हर स्टैक स्तर पर ईआईपी है, न कि यह जहां से उत्पन्न होता है। वर्तमान में त्रुटियाँ हैं a) वर्तमान में तुलनीय नहीं हैं और b) सिर्फ इसलिए कि वे बराबर की तुलना करते हैं इसका मतलब यह नहीं है कि वे एक ही त्रुटि हैं।

कितनी समवर्ती त्रुटियों से आप चाहते हैं कि स्टैकट्रैक को कभी भी एक साथ प्रचारित किया जाए

किसी भी त्रुटि को पकड़ा गया और अलग-अलग त्रुटि के रूप में पुनर्विचार किया गया।

मैं परिणाम-विशिष्ट कंपाइलर हैक्स को व्यक्तिगत रूप से जोड़ने के खिलाफ हूं, जब सरल समाधान काम करते हैं।

मैं नहीं देखता कि कैसे एक सरल समाधान काम करता है, लेकिन शायद मैं वहां कुछ याद कर रहा हूं।

आप निर्देश सूचक को प्रत्येक ? पर सहेज सकते हैं और त्रुटि प्रकार के साथ इसे संबद्ध कर सकते हैं।
"कोई भी त्रुटि पकड़ी गई और अलग-अलग त्रुटि के रूप में पुन: प्रकट हुई।" लेकिन अगर आप Result में छिपे हों तो आप उस जानकारी को कैसे संरक्षित करेंगे?

लेकिन अगर आप रिजल्ट में छिपे होते हैं तो आप उस जानकारी को कैसे संरक्षित करेंगे?

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

एक तरीका यह होगा कि आप परिणाम पर failure_id(&self) एक तरीका अपनाते हैं और यह एक i64 / uuid या ऐसा कुछ देता है जो विफलता की उत्पत्ति की पहचान करता है।

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

"कंपाइलर स्टैक फ्रेम को रिकॉर्ड करने के लिए एक निर्देश देता है जो इसके माध्यम से गिरता है" - लेकिन ? स्पष्ट है, यह अपवादों की तरह कुछ भी नहीं है, या क्या आपको _only_ ? इसे रिकॉर्ड करना पसंद नहीं है?

वैसे भी, यदि आप मैन्युअल रूप से त्रुटि को अनपैक करते हैं और फिर उसे Err में वापस रख देते हैं, तो उस आईडी को कैसे रखा जाएगा?

"और क्योंकि त्रुटि विशेषता सिर्फ एक विशेषता है और इसमें भंडारण नहीं है, इसे परिणाम में संग्रहीत किया जा सकता है"
इस पर एक प्रकार है: Error गुण को लागू करने के लिए संकलक में विशेष-आवरण किया जा सकता है प्रकार में एक अतिरिक्त पूर्णांक फ़ील्ड को जोड़ने के लिए, प्रकार बनाने से एक आईडी उत्पन्न होगी, और कॉपी / ड्रॉप करें प्रभावी रूप से वेतन वृद्धि / गिरावट (और अंततः इसे TLS से "इन-फ़्लाइट एरर सेट" यदि Result::unwrap उपयोग नहीं किया गया है)।

लेकिन वह Copy विशेषता के साथ संघर्ष करेगा। मेरा मतलब है, इसलिए आपकी योजना, Result कि किसी भी विशेष व्यवहार को जोड़कर _not_ ? या अन्य विशिष्ट उपयोगकर्ता क्रियाओं से ट्रिगर नहीं होगी, Copy अपरिवर्तनों को अमान्य कर सकती है।

संपादित करें : इस बिंदु पर आप एक Rc<ErrorTrace> में एम्बेड कर सकते हैं।
EDIT2 : मैं क्या कह रहा हूं, आप catch पर संबंधित त्रुटि ट्रेस को साफ़ कर सकते हैं।
EDIT3 : वास्तव में, ड्रॉप पर, बेहतर स्पष्टीकरण के नीचे देखें।

"कंपाइलर स्टैक फ्रेम को रिकॉर्ड करने के लिए एक निर्देश देता है जो इसके माध्यम से गिरता है" - लेकिन? स्पष्ट है, यह अपवाद जैसा कुछ नहीं है, या क्या आप केवल रिकॉर्डिंग पसंद नहीं करते हैं? यह गुजर गया?

यह काम नहीं करता है क्योंकि बहुत सारे फ्रेम हैं जो आप गिर सकते हैं जिसके माध्यम से ? उपयोग न करें। अकेले जाने दें कि हर कोई ? साथ त्रुटियों को संभालने वाला नहीं है।

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

इसलिए इसे कंपाइलर सपोर्ट करना होगा। कंपाइलर को स्थानीय चर को ट्रैक करना होगा जो परिणाम हैं और रि-रैप्स के लिए परिणाम आईडी को आगे की ओर प्रचारित करना सबसे अच्छा है। यदि यह बहुत जादुई है तो इसे संचालन के सबसेट तक सीमित किया जा सकता है।

यह काम नहीं करता है क्योंकि बहुत सारे फ्रेम हैं जो आप गिर सकते हैं जिसके माध्यम से ? उपयोग न करें। अकेले जाने दें कि हर कोई ? साथ त्रुटियों को संभालने वाला नहीं है।

ठीक है, मैं कई रिटर्न पथों के साथ जटिल कार्यों में सीधे Result वापस लौट सकता हूं (जिनमें से कुछ ? से शुरुआती रिटर्न होगा)।

यदि यह बहुत जादुई है तो इसे संचालन के सबसेट तक सीमित किया जा सकता है।

या पूरी तरह से स्पष्ट कर दिया। क्या आपके पास गैर- ? री-रैपिंग के उदाहरण हैं जो कंपाइलर द्वारा जादुई रूप से ट्रैक किए जाने होंगे?

@eddyb त्रुटियों के मैनुअल हैंडलिंग का सामान्य मामला एक IoError है जहां आप एक सबसेट संभालना चाहते हैं:

loop {
  match establish_connection() {
    Ok(conn) => { ... },
    Err(err) => {
      if err.kind() == io::ErrorKind::ConnectionRefused {
        continue;
      } else {
        return Err(err);
      }
    }
  }
}

@mitsuhiko तब io::Error अंदर आईडी रखने से निश्चित रूप से काम होगा।

इसलिए पुनर्पूंजीकरण करने के लिए, Vec<Option<Trace>> "विरल पूर्णांक का नक्शा" TLS में, struct ErrorId(usize) और 3 लैंग आइटम्स द्वारा एक्सेस किया गया:

• fn trace_new(Location) -> ErrorId , जब एक गैर- const त्रुटि मूल्य बनाते हैं
• fn trace_return(ErrorId, Location) , किसी फ़ंक्शन से लौटने से पहले _declared_ के रूप में -> Result<...> (यानी वापसी पर कोई फ़ंक्शन सामान्य नहीं है कि _happens_ का उपयोग Result प्रकार से किया जाए)
• fn trace_destroy(ErrorId) , जब एक त्रुटि मूल्य ड्रॉप

यदि परिवर्तन MIR पर किया जाता है, तो Location गणना Span निर्देश के Lvalue::Return लिख सकता है, जो बहुत अधिक विश्वसनीय है एक निर्देश सूचक IMO (एलएलवीएम में वैसे भी प्राप्त करने का कोई आसान तरीका नहीं है, आपको प्रत्येक विशिष्ट प्लेटफॉर्म के लिए इनलाइन asm का उत्सर्जन करना होगा)।

@eddyb

बाइनरी आकार ब्लोट के लिए नेतृत्व नहीं करेंगे?

@ arielb1 आप इसे डिबग मोड में ही करेंगे जहां

@ हेड्डी उस मामले में एक स्थान क्या है? यकीन नहीं होता कि आईपी पढ़ने में क्या मुश्किल है। निश्चित रूप से, आपको प्रत्येक लक्ष्य के लिए कस्टम JS की आवश्यकता है लेकिन वास्तव में यह सब कठिन नहीं है।

@mitsuhiko यह वही जानकारी हो सकती है जिसका उपयोग हम ओवरफ्लो जाँच और अन्य संकलक उत्सर्जित पैनिक्स के लिए करते हैं। core::panicking::panic ।

एक ढेर Error स्टैक की जानकारी को Result क्यों पैक करें जबकि स्टैक अनवाउंड है? क्यों नहीं बस कोड चलाते हैं जबकि स्टैक अभी भी है? उदा यदि स्टैक के रास्ते पर चर में रुचि रखते हैं तो क्या करें? बस लोगों को कस्टम कोड चलाने में सक्षम करें जब एक Err आह्वान किया जाता है, जैसे अपनी पसंद के डिबगर को कॉल करने के लिए। यह वही है जो try! पहले से ही एक (अति-प्रशंसनीय) मैक्रो होने के कारण प्रदान करता है। सबसे आसान तरीका एक Err केस पर घबराना है जो स्टैक प्रिंट करता है बशर्ते कि कार्यक्रम सही पैरामेट्स के साथ शुरू किया गया हो।

try आप कुछ भी कर सकते हैं, जो आप Err केस पर चाहते हैं, और आप मैक्रो क्रेट को ओवरराइड कर सकते हैं, या प्रदर्शन महत्वपूर्ण कोड को न छूने के लिए बहुत डरा हुआ है जैसे कि त्रुटि को पुन: उत्पन्न करने के लिए कठिन है आपको संपूर्ण महत्वपूर्ण कोड की एक बहुत चलाने की आवश्यकता है।

किसी को भी एक कृत्रिम स्टैक में जानकारी के एक अंश को संरक्षित करने की आवश्यकता नहीं होती है, क्योंकि वास्तविक नष्ट होने वाला है। सभी मैक्रो ओवरराइडिंग विधि में सुधार किया जा सकता है:

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

@ est31 एक आतंक की तरह स्टैक नहीं है _automatically_ "अनबाउंड", यह प्रारंभिक रिटर्न के लिए सिंथेटिक चीनी है।
और हाँ, आपके पास कुछ खाली फ़ंक्शंस के संकलक सम्मिलित कॉल हो सकते हैं जिनके निश्चित नाम हैं जिन पर आप विराम लगा सकते हैं, यह बहुत आसान है (और ऐसी जानकारी भी है जो आपको करने देती है, जैसे call dump(data) - जहाँ dump और data तर्क डीबगर देख सकते हैं)।

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

@hexsel हाँ, यही वजह है कि मैं Result::unwrap या कुछ नया ignore पद्धति (या हमेशा त्रुटि छोड़ने पर भी?) stderr को ट्रेस करता है।

@ हेड्डी अगर आप टीएलएस में डेटा संरचना जैसे स्टैक के मान से प्राप्त निर्देश सूचक या कुछ जोड़ते हैं तो आप मूल रूप से वास्तविक जीवन स्टैक के अपने छोटे संस्करण का पुनर्निर्माण करते हैं। एक वापसी एक प्रविष्टि से स्टैक को कम करती है। इसलिए यदि आप ऐसा करते हैं कि आप लौटते समय _unwind_ स्टैक का हिस्सा, जबकि रैम में किसी अन्य स्थान पर इसका सीमित संस्करण बनाते हैं। शायद "कानूनी" रिटर्न के परिणामस्वरूप व्यवहार के लिए गलत शब्द है, लेकिन अगर सभी कोड ? या try! और अंत में आप अंत में परिणाम समान है। इसका महान यह है कि जंग त्रुटि प्रसार को स्वचालित नहीं बनाता है, मुझे वास्तव में पसंद आया कि कैसे जावा को throws कीवर्ड के बाद सूचीबद्ध होने के लिए सभी अपवादों की आवश्यकता थी, जंग उस पर एक अच्छा सुधार है।

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

@ est31 try! ओवरराइड करना आपके अपने कोड में काम करता है (यह सचमुच मैक्रो इम्पोर्ट शैडोइंग है), यह हमारे "कमजोर लैंग आइटम" की तरह कुछ अलग होना होगा।

@ est31 वास्तव में सही नहीं है (तनाव मुक्त के बारे में), निशान और वास्तविक ढेर जरूरी, किसी भी संबंध नहीं है ऐसा इसलिए है क्योंकि चलती Result मूल पश्व-अनुरेखन में ऊपर जाने के लिए नहीं है चारों ओर, यह जा सकते हैं बग़ल में भी।
इसके अलावा, यदि बाइनरी को अनुकूलित किया जाता है, तो अधिकांश बैकट्रेस चला जाता है, और यदि आपके पास डिबग जानकारी नहीं है, तो Location सख्ती से बेहतर है। तुम भी एक obfuscating प्लगइन चल सकता है जो यादृच्छिक हैश के साथ सभी स्रोत जानकारी को बदलता है जिसे कुछ बंद स्रोत उत्पाद के डेवलपर्स द्वारा मिलान किया जा सकता है।

डिबगर उपयोगी होते हैं (और एक तरफ के रूप में, मैं lldb क्लीनर बैकट्रेस आउटपुट से प्यार कर रहा हूं), लेकिन वे रामबाण नहीं हैं, और हम पहले से ही पैनिक पर कुछ जानकारी का उत्पादन करते हैं ताकि आपको कुछ सुराग मिल सकें। क्या चल रहा है।

इसके बारे में - मेरे पास कुछ प्रकार के सिस्टम-स्तरीय ट्रिक के बारे में विचार था, जहां {Option,Result}::unwrap में एक अतिरिक्त प्रकार का तर्क होगा, जिस स्थान से फ़ंक्शन को कॉल किया गया था उस पर निर्भर एक प्रकार के लिए डिफ़ॉल्ट, इस तरह से पैनिक से रास्ता होगा अधिक उपयोगी स्थान की जानकारी।

वैल्यू पैराड्राइज़ेशन पर प्रगति के साथ, यह अभी भी एक विकल्प हो सकता है, लेकिन निश्चित रूप से केवल एक ही नहीं है, और मैं Result निशान को सीधे खारिज नहीं करना चाहता, इसके बजाय मैं एक मॉडल खोजने की कोशिश कर रहा हूं जो _implementable_ है।

try! ओवरराइड करना बिल्कुल भी समाधान नहीं है क्योंकि यह आपके अपने टोकरे में निहित है। यह डिबगिंग अनुभव के रूप में अस्वीकार्य है। मैंने पहले ही बहुत कोशिश की थी कि मौजूदा try! से निपटने की कोशिश

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

यह DWARF जानकारी की तुलना में काफी अधिक बेकार कैसे होगा? फ़ाइलनामों को काट दिया जाएगा, और x64 पर पूरी चीज़ 3 पॉइंटर्स का आकार है।

@mitsuhiko मूल रूप से, आप सामान्य दिशा से सहमत हैं, लेकिन तकनीकी बारीकियों के साथ नहीं?

एक सामान्य जंग एपीआई के लिए DWARF जानकारी को उजागर करना कितना आसान है?

@eddyb क्योंकि DWARF की जानकारी रिलीज़ बाइनरी के भीतर नहीं बल्कि अलग-अलग फाइलों में समाहित है। तो मैं प्रतीकों सर्वर पर डीबग फ़ाइलें हो सकता है और उपयोगकर्ताओं के लिए एक छीन बाइनरी जहाज।

@mitsuhiko ओह, यह एक पूरी तरह से अलग दृष्टिकोण है जो मैं मान रहा था। जंग वर्तमान में उस एएफएआईके को समर्थन नहीं करती है, लेकिन मैं मानता हूं कि यह होना चाहिए।

क्या आपको लगता है कि निर्देश बिंदु वास्तव में हैं जो बेनर रिलीजिंग बायनेरिज़ के उद्देश्यों के लिए आपके बिल्ड सिस्टम द्वारा उत्पन्न यादृच्छिक पहचानकर्ताओं की तुलना में उपयोगी हैं?

मेरा अनुभव रहा है कि स्पष्ट आत्म / पारस्परिक पुनरावृत्ति और बहुत बड़े कार्यों को छोड़कर, किसी भी इनलाइनिंग डिबगर्स के पास स्टैक ट्रेस को पुनर्प्राप्त करने में कठिन समय होता है।

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

क्या दोनों दृष्टिकोणों को सक्षम करने के बारे में, और डेवलपर को यह तय करने दें कि उनके लिए सबसे अच्छा क्या है? मैं इस बात से इनकार नहीं करता कि टीएलएस आधारित दृष्टिकोण का कोई लाभ नहीं है।

प्रयास मॉडल बहुत आसानी से लागू होता है, बस ? try , केवल अतिरिक्त भाषा एक्सटेंशन की आवश्यकता होती है यदि catch आता है (आपने हार्डकोर व्यवहार के अंदर उस व्यवहार को जोड़ दिया होगा) ? वैसे भी)

@eddyb "क्या आपको लगता है कि निर्देश बेनर रिलीजिंग बायनेरिज़ के उद्देश्यों के लिए आपके बिल्ड सिस्टम द्वारा उत्पन्न यादृच्छिक पहचानकर्ताओं की तुलना में उपयोगी हैं?"

यह कैसे सामान्य कामों में देशी बायनेरिज़ डिबगिंग है। हम (संतरी) इस बिंदु पर लगभग पूरी तरह से iOS समर्थन के लिए उपयोग कर रहे हैं। हमें एक क्रैश डंप मिलता है और वास्तविक प्रतीकों के लिए llvm-symbolizer वाले पतों को हल करता है।

libbacktrace मित्सुहिको चूंकि हम पहले से ही libbacktrace एम्बेड करते हैं,

@ हेड्डी हाँ। सिर्फ पैनिक कोड को देखा। अच्छा होगा यदि वह वास्तव में एक एपीआई था जिसे रस्ट कोड उपयोग कर सकता है। मैं इसे कुछ और जगहों पर उपयोगी होते हुए देख सकता हूँ।

इसके बारे में - मेरे पास एक टाइप-लेवल ट्रिक के बारे में कुछ विचार थे, जहाँ {Option, Result} :: undrap में एक अतिरिक्त प्रकार का तर्क होगा, जिस स्थान से फ़ंक्शन को कॉल किया गया था, उस स्थान पर निर्भर एक प्रकार के लिए डिफ़ॉल्ट, जैसे कि उन लोगों से पैनिक। जिस तरह से अधिक उपयोगी स्थान जानकारी है।

बाते कर रहे हैं जिससे कि...

@glaebhoerl हैह , हो सकता है कि वास्तव में पीछा करने लायक हो? कम से कम कुछ अस्थिर प्रयोग के रूप में।

@eddyb कोई विचार नहीं है। संभवत: पहले इसके साथ जुड़े कुछ GHCers के साथ इस पर चर्चा करने के लायक है, मैंने केवल इस बारे में सुना है और अभी एक लिंक को गुगला दिया है। और Rust के पास वास्तविक अंतर्निहित पैरामीटर नहीं है जिस तरह से GHC करता है; इसके बजाय डिफ़ॉल्ट प्रकार के पैरामीटर काम कर सकते हैं या नहीं, यह एक दिलचस्प सवाल है (शायद एक जो आपने I से अधिक सोचा है)।

बस एक विचार: यह एक स्विच करने के लिए उपयोगी होगा जो rustc का कारण बनता है विशेष-केस में Err निर्माण होता है, जो कि लौटने से पहले पेलोड के साथ fn(TypeId, *mut ()) कार्य करता है । यदि पेलोड के आधार पर त्रुटियों को फ़िल्टर करना, डिबगर में फंसना, अगर यह ब्याज की त्रुटि देखता है, या कुछ विशेष प्रकार की त्रुटियों के लिए बैकट्रैक कैप्चर करना जैसे बुनियादी सामान के साथ शुरू करने के लिए पर्याप्त होना चाहिए।

PR 33389 Carrier विशेषता के लिए प्रयोगात्मक समर्थन जोड़ता है। चूँकि यह मूल RFC का हिस्सा नहीं था, इसलिए हमें विशेष रूप से परीक्षा और चर्चा के करीब का समय मिलना चाहिए, इससे पहले कि हम FCP (जो शायद अलग होना चाहिए FCP बाकी ? ऑपरेटर के लिए)। अधिक विवरण के लिए इस चर्चा धागे को देखें।

मैं ? से Option s का विस्तार करने का विरोधी हूं।

RFC का शब्दांकन इस तथ्य के बारे में स्पष्ट है कि ? ऑपरेटर त्रुटियों / "अपवादों" को प्रचारित करने के बारे में है।
किसी त्रुटि की रिपोर्ट करने के लिए Option का उपयोग करना गलत उपकरण है। None एक सफल प्रोग्राम के सामान्य वर्कफ़्लो का हिस्सा है, जबकि Err हमेशा वापस आना एक त्रुटि को दर्शाता है।

यदि हम कभी भी त्रुटियों से निपटने के कुछ क्षेत्रों में सुधार करना चाहते हैं (उदाहरण के लिए स्टैक के निशान जोड़कर), ? को Option अर्थ है कि हमें परिवर्तनों से ? बाहर करना होगा। ।

@tomaka क्या हम चर्चा के सूत्र पर चर्चा रख सकते हैं? (मैंने पहले ही आपकी आपत्ति को संक्षेप में प्रस्तुत कर

@eddyb यहाँ पहले बताए गए अंतर्निहित कॉलस्टैक्स GHC फीचर के रिलीज़-संस्करण डॉक्स हैं।

थोड़ी देर में यहां कोई अपडेट नहीं। क्या कोई इसे आगे बढ़ाने के लिए काम कर रहा है? क्या ओपी में शेष कार्य अभी भी सटीक हैं? क्या यहां कुछ भी ई-हेल्प-वॉन्टेड हो सकता है?

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

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

दुर्भाग्य से मैं वर्तमान में यह नहीं देखता कि कैसे बड़े पैमाने पर परिवर्तन के बिना आईपी को रिकॉर्ड किया जा सकता है कि परिणाम कैसे काम करते हैं। क्या किसी और ने पहले इस विचार के साथ खेला है?

हम इस पर @ जंग-लंग / लंग मीटिंग में चर्चा कर रहे थे। कुछ बातें जो सामने आईं:

सबसे पहले, ? जितनी जल्दी हो सके ? Option पर ऑपरेटिंग नहीं देखना चाहेंगे और न केवल Result (लेकिन ऐसा नहीं है, मुझे लगता है कि, bool , के रूप में भी प्रस्तावित किया गया है)। स्थिरीकरण के बारे में एक चिंता यह है कि यदि हम किसी भी प्रकार के विशेषता की पेशकश किए बिना स्थिर करते हैं जो Result अलावा अन्य प्रकार की अनुमति देगा, तो यह बाद में जोड़ने के लिए पीछे की ओर संगत नहीं है।

उदाहरण के लिए, मैं खुद कुछ नियमितता के साथ इस तरह कोड लिखता हूं:

let v: Vec<_> = try!(foo.iter().map(|x| x.to_result()).collect());

मैं कहाँ पर भरोसा कर रहा हूँ try! प्रकार निष्कर्ष सूचित करना है कि मैं उम्मीद collect एक वापस जाने के लिए Result<Vec<_>, _> । यदि ? , तो यह अनुमान _might_ भविष्य में विफल हो जाता है।

हालाँकि, पिछली चर्चाओं में हमने यह भी तय किया था कि किसी भी प्रकार के "वाहक" गुण के महीन बिंदुओं पर चर्चा करने के लिए एक संशोधन RFC की आवश्यकता थी। स्पष्ट रूप से इस RFC को ASAP लिखा जाना चाहिए, लेकिन हम उस चर्चा पर ? प्रगति को अवरुद्ध नहीं करना चाहेंगे।

एक विचार यह था कि यदि हमने @nrc का कार्यान्वयन लिया और हमने लक्षण को अस्थिर कर दिया और इसे केवल Result और कुछ निजी डमी प्रकार के लिए लागू कर दिया, तो हमें केवल ? बनाने के दौरान विरोध को दबाने की जरूरत Result साथ ? उपयोगी।

एक अंतिम बिंदु: मुझे लगता है कि हम में से अधिकांश यह पसंद करेंगे कि यदि आप ? का उपयोग Option मूल्य पर करते हैं, तो यह आवश्यक है कि आपके फ़ंक्शन का रिटर्न प्रकार भी Option होना चाहिए (उदाहरण के लिए नहीं) Result<T,()> )। यह ध्यान रखना दिलचस्प है कि यह निष्कर्ष सीमाओं के साथ मदद करेगा, क्योंकि हम अंततः कई मामलों में घोषित रिटर्न प्रकार से अनुमान लगा सकते हैं कि किस प्रकार की आवश्यकता है।

अंतर-रूपांतरण नहीं चाहने का कारण यह है कि सी लॉजिक की संभावना कम लगती है, सी के समान कैसे if x अनुमति देता है, भले ही x का अभिन्न प्रकार हो। यही है, अगर Option<T> एक मूल्य को दर्शाता है, जहां None उस मूल्य के डोमेन का हिस्सा है (जैसा कि उसे होना चाहिए), और Result<> प्रतिनिधित्व करता है (आमतौर पर) एक फ़ंक्शन की विफलता सफल होने के लिए, तब यह मानते हुए कि None मतलब है कि फ़ंक्शन को त्रुटि का संदेह होना चाहिए (और एक तरह का मनमाना हस्तक्षेप)। लेकिन वह चर्चा RFC की प्रतीक्षा कर सकती है, मुझे लगता है।

अंतर-रूपांतरण नहीं चाहने का कारण यह है कि सी लॉजिक, सी if x अनुमति देता है, यहां तक ​​कि जब x का अभिन्न प्रकार होता है, तो इसके अनुरूप होने की संभावना है। यही है, अगर Option<T> एक मूल्य को दर्शाता है जहाँ None उस मूल्य के डोमेन का हिस्सा है (जैसा कि उसे होना चाहिए), और Result<> प्रतिनिधित्व करता है (आमतौर पर) एक फ़ंक्शन की विफलता सफल होने के लिए, तब यह मानते हुए कि None अर्थ है कि फ़ंक्शन को त्रुटि का संदेह होना चाहिए (और एक तरह का मनमाना हस्तक्षेप)। लेकिन वह चर्चा RFC की प्रतीक्षा कर सकती है, मुझे लगता है।

मैं दिल से इससे सहमत हूं।

एक और सवाल जिस पर हम गेट स्टेबलाइजेशन के लिए सहमत हुए थे, वह अनुबंधों को खत्म कर रहा था कि impl s From विशेषता का पालन करना चाहिए (या जो भी विशेषता हम Err -upcasting के लिए उपयोग कर रहे हैं) )।

@glaebhoerl

गेट स्टैबलाइजेशन पर एक और सवाल जिस पर हमने सहमति जताई थी वह यह था कि कॉन्ट्रैक्ट्स से यह पता चल रहा था कि फ्रेट ट्रैक्ट का पालन करना चाहिए (या एरर-अपकास्टिंग के लिए हम जो भी पवन का इस्तेमाल करते हैं)।

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

वैसे, catch अभिव्यक्तियों की स्थिति क्या है? क्या वे लागू हैं?

दुख की बात है नहीं :(

Tue, Jul 26, 2016 को 06:41:44 पूर्वाह्न -0700 पर, अलेक्जेंडर बुलावा ने लिखा:

वैसे, catch अभिव्यक्तियों की स्थिति क्या है? क्या वे लागू हैं?

---

आप इसे प्राप्त कर रहे हैं क्योंकि आपने थ्रेड को अधिकृत किया है।
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें:
https://github.com/rust-lang/rust/issues/31436#issuecomment -235270663

शायद आपको इसे लागू करने की योजना बनानी चाहिए? स्वीकृत से अधिक निराशाजनक कुछ भी नहीं है लेकिन कार्यान्वित RFC नहीं है ...

cc # 35056

FYI करें, https://github.com/rust-lang/rfcs/pull/1450 (enum वेरिएंट के लिए प्रकार) Carrier लागू करने के लिए कुछ दिलचस्प तरीके खोलेंगे। उदाहरण के लिए, कुछ इस तरह:

trait Carrier {
    type Success: CarrierSuccess;
    type Error: CarrierError;
}

trait CarrierSuccess {
    type Value;
    fn into_value(self) -> Self::Value;
}

// (could really use some HKT...)
trait CarrierError<Equivalent: CarrierError> {
    fn convert_error(self) -> Equivalent;
}

impl<T, E> Carrier for Result<T, E>
{
    type Success = Result::Ok<T, E>;
    type Error = Result::Err<T, E>;
}

impl<T, E> CarrierSuccess for Result::Ok<T, E> {
    type Value = T;
    fn into_value(self) -> Self::Value {
        self.0
    }
}

impl<T, E1, E2> CarrierError<Result::Err<T, E2>> for Result::Err<T, E1>
    where E2: From<E1>,
{
    fn convert_error(self) -> Result::Err<T, E2> {
        Err(self.into())
    }
}

impl<T> Carrier for Option<T>
{
    type Success = Option::Some<T>;
    type Error = None;
}

impl<T> CarrierSuccess for Option::Some<T> {
    type Value = T;
    fn into_value(self) -> Self::Value {
        self.0
    }
}

impl<T> CarrierError<Option::None> for Option::None {
    fn convert_error(self) -> Option::None {
        self
    }
}

fn main() {
    let value = match might_be_err() {
        ok @ Carrier::Success => ok.into_value(),
        err @ Carrier::Error => return err.convert_error(),
    }
}

मैं सिर्फ https://github.com/rust-lang/rust/pull/35056#issuecomment -240129923 से कुछ विचार पार करना चाहता था। वह PR डमी प्रकार के साथ Carrier विशेषता का परिचय देता है। इरादा सुरक्षित करने का था - विशेष रूप से, हम बिना किसी प्रकार के अवरोध के साथ अपनी बातचीत को स्थिर किए बिना ? को स्थिर करना चाहते थे। विशेषता प्लस डमी प्रकार का यह संयोजन ऐसा लग रहा था कि यह सुरक्षित रूप से रूढ़िवादी होगा।

यह विचार था (मुझे लगता है) कि हम तब Carrier चर्चा करने वाले RFC को लिखेंगे और डिजाइन को संशोधित करने का प्रयास करेंगे, केवल तब जब हम समग्र आकार से खुश थे (या संभवतः Carrier को हटाकर।

अब, थोड़ा और सट्टा बोलते हुए, I _anticipate_, अगर हम Carrier गुण अपनाते हैं, तो हम वाहकों के बीच के अंतरविरोध को समाप्त करना चाहेंगे (जबकि यह गुण मूल रूप से Result से / में बदलने का एक तरीका है) ? Option , तो यह ठीक है यदि fn Option लौटाता है; और यदि आप ? Result<T,E> , तो यह ठीक है यदि fn Result<U,F> जहां E: Into<F> ; लेकिन अगर आप ? को Option और fn Result<..> , तो यह ठीक नहीं है।

इस प्रकार का नियम आज की प्रकार प्रणाली में व्यक्त करना कठिन है। सबसे स्पष्ट शुरुआती बिंदु एचकेटी की तरह कुछ होगा (बेशक जो हमारे पास वास्तव में नहीं है, लेकिन आइए इसे अभी तक अनदेखा करें)। हालाँकि, यह स्पष्ट रूप से सही नहीं है। यदि हम इसका उपयोग करने वाले थे, तो कोई यह मान लेगा कि Self पैरामीटर Carrier पास type -> type -> type , क्योंकि Result Carrier लागू कर सकते हैं । यह हमें Self<T,E> -> Self<U,F> जैसी चीजों को व्यक्त करने की अनुमति देगा। हालाँकि, यह _not_ आवश्यक रूप से Option लिए लागू होगा, जिसमें type -> type (यह सब निश्चित रूप से एचकेटी प्रणाली को किस प्रकार हमने अपनाया पर निर्भर करेगा, लेकिन मुझे नहीं लगता कि हम ' सभी तरह से "सामान्य प्रकार के लैंबडास" पर जाएंगे)। इससे भी अधिक चरम bool एक प्रकार हो सकता है (हालांकि मैं बूल के लिए Carrier लागू नहीं करना चाहता, मुझे उम्मीद है कि कुछ लोग Carrier एक न्यूटाइप के लिए लागू करना चाहेंगे) 'd बूल)।

मैंने जो माना था कि ? लिए टाइपिंग नियम स्वयं विशेष हो सकते हैं: उदाहरण के लिए, हम कह सकते हैं कि ? केवल नाममात्र प्रकार के लिए लागू किया जा सकता है Foo<..> _some_ दयालु, और यह कि यह इस प्रकार के खिलाफ Carrier विशेषता से मेल खाएगा, लेकिन इसके लिए यह आवश्यक होगा कि संलग्न fn का रिटर्न प्रकार भी Foo<..> । तो हम मूल रूप से ताजे प्रकार के मापदंडों के साथ Foo को तुरंत इंस्टेंट करेंगे। इस विचार का नकारात्मक पक्ष यह है कि यदि न तो ? टाइप किया जा रहा है और न ही संलग्नक fn के प्रकार को ज्ञात किया जा रहा है, तो हम इस बाधा को कुछ नए प्रकार के विशेषता दायित्व को शामिल किए बिना लागू नहीं कर सकते। यह भी तदर्थ है। :) लेकिन यह काम करेगा।

एक और विचार यह था कि हम Carrier विशेषता पर पुनर्विचार कर सकते हैं। यह विचार Expr: Carrier<Return> जहां Expr ? टाइप किया जाता है और Return पर्यावरण का प्रकार है। उदाहरण के लिए, शायद यह इस तरह दिखे:

trait Carrier<Target> {
    type Ok;
    fn is_ok(&self) -> bool; // if true, represents the "ok-like" variant
    fn unwrap_into_ok(self) -> Self::Ok; // may panic if not ok
    fn unwrap_into_error(self) -> Target; // may panic if not error
}

फिर expr? डिगगर को:

let val = expr;
if Carrier::is_ok(&val) {
    val.unwrap_into_ok()
} else {
    return val.unwrap_into_error();
}

यहाँ मुख्य अंतर यह है कि Target _error_ प्रकार नहीं होगा, बल्कि एक नया Result प्रकार होगा। इसलिए उदाहरण के लिए हम निम्नलिखित जोड़ जोड़ सकते हैं:

impl<T,U,E,F> Carrier<Result<U,F>> for Result<T,E>
    where E: Into<F>
{
    type Ok = T;
    fn is_ok(&self) -> bool { self.is_ok() }
    fn unwrap_into_ok(self) -> Self::Ok { self.unwrap() }
    fn unwrap_into_error(self) -> { Err(F::from(self.unwrap_err())) }
}

और फिर हम जोड़ सकते हैं:

impl<T> Carrier<Option<T>> for Option<T> {
    type Ok = T;
    fn is_ok(&self) -> bool { self.is_some() }
    fn unwrap_into_ok(self) -> Self::Ok { self.unwrap() }
    fn unwrap_into_error(self) -> { debug_assert!(self.is_none()); None }
}

और अंत में हम बूल के लिए लागू कर सकते हैं जैसे:

struct MyBool(bool);
impl<T> Carrier<MyBool> for MyBool {
    type Ok = ();
    fn is_ok(&self) -> bool { self.0 }
    fn unwrap_into_ok(self) -> Self::Ok { debug_assert!(self.0); () }
    fn unwrap_into_error(self) -> { debug_assert!(!self.0); self }
}

अब यह संस्करण अधिक लचीला है। उदाहरण के लिए, हम के बीच interconversion अनुमति देते हैं _could_ Option मूल्यों के लिए परिवर्तित किया Result जोड़कर एक impl की तरह:

impl<T> Carrier<Result<T,()>> for Option<T> { ... }

लेकिन निश्चित रूप से हमारे पास नहीं है (और हम नहीं करेंगे)।

@Stebalien

FYI करें, जंग-लंग / rfcs # 1450 (एनम वेरिएंट के लिए प्रकार) कुछ दिलचस्प तरीके खोलेंगे वाहक लागू

जैसा कि मैंने उस विचार को लिख रहा था, जो मैंने अभी लिखा था, मैं सोच रहा था कि एनम वेरिएंट के प्रकार हैं, और यह कैसे चीजों को प्रभावित कर सकता है।

एक बात मैंने कुछ कोड लिखने पर गौर किया, जो ? का उपयोग करता है, यह है कि यह किसी भी तरह के "थ्रो" कीवर्ड को लेकर परेशान नहीं करता है - विशेष रूप से, यदि आप Err(foo)? लिखते हैं, तो कंपाइलर नहीं आता ' t _know_ कि यह वापस आ जाएगा, इसलिए आपको return Err(foo) लिखना होगा। यह ठीक है, लेकिन तब आपको into() रूपांतरण बिना उन्हें लिखे नहीं मिलते।

इस तरह के मामलों में आता है:

let value = if something_or_other() { foo } else { return Err(bar) };

ओह, मुझे एक और बात जोड़ना चाहिए। तथ्य यह है कि हम टाइप करने के लिए प्रभाव को प्रभावित करने की अनुमति देते हैं _should_ का मतलब है कि foo.iter().map().collect()? , उस संदर्भ में जहां fn Result<..> लौटाता है, मुझे संदेह है कि किसी भी प्रकार के एनोटेशन की आवश्यकता नहीं होगी, क्योंकि यदि वह जानते हैं कि fn रिटर्न प्रकार Result , केवल एक ही निहित संभावित रूप से लागू होगा (स्थानीय रूप से, कम से कम)।

ओह, और, मेरे Carrier विशेषता का थोड़ा बेहतर संस्करण शायद होगा:

trait Carrier<Target> {
    type Ok;
    fn into_carrier(self) -> Result<Self::Ok, Target>;
}

जहाँ आप इसे लागू करेंगे:

impl<T,U,E,F> Carrier<Result<U,F>> for Result<T,E>
    where E: Into<F>
{
    type Ok = T;
    fn into_carrier(self) -> Result<T, Result<U,F>> {
        match self { Ok(v) => Ok(v), Err(e) => Err(e.into()) }
    }
}

और expr? जैसे कोड उत्पन्न होंगे:

match Carrier::into_carrier(expr) {
    Ok(v) => v,
    Err(e) => return e,
}

इस के एक नकारात्मक पक्ष (या उल्टा ...) यह है कि Into रूपांतरणों को धक्का दिया जाता है, जिसका अर्थ है कि लोग इसका उपयोग तब नहीं कर सकते जब यह समझ में आता है। लेकिन इसका मतलब यह भी है कि यदि आप वांछित नहीं हैं तो आप उन्हें निष्क्रिय कर सकते हैं।

@nikomatsakis IMO, गुण इस तरह से फिर से उपयोग करने के बजाय IntoCarrier और IntoCarrier::into_carrier होना चाहिए, Carrier (एक नया ईनाम)। अर्थात्:

enum Carrier<C, R> {
    Continue(C),
    Return(R),
}
trait IntoCarrier<Return> {
    type Continue;
    fn into_carrier(self) -> Carrier<Self::Continue, Return>;
}

@Stebalien यकीन है, ठीक लगता है।

लैंग टीम की बैठक में चर्चा के लिए नामांकन (और संभव ? अकेले ऑपरेटर का)। मुझे लगता है कि हमें अगले कुछ दिनों में अस्थायी कैरियर गुण के कुछ प्रकार को उतारने की आवश्यकता है FCP।

मैंने कैरियर विशेषता पर चर्चा करने के लिए जंग-लंग / rfcs # 1718 खोला।

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

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

@ रस्ट-लैंग / लैंग के सदस्य, कृपया अपना नाम सिग्नल समझौते के लिए जांचें। चिंताओं या आपत्तियों के साथ एक टिप्पणी छोड़ दें। अन्य, कृपया टिप्पणी छोड़ें। धन्यवाद!

• [x] @ मुनोमकोत्सकिस
• [x] @nrc
• [x] @ न्यूटन
• [x] @ हेड्डी
• [] @pnkfelix (छुट्टी पर)

मुझे आश्चर्य है कि अगर टोकियो आधारित पुस्तकालय and_then बहुत का उपयोग करके समाप्त हो जाएंगे। यह foo().?bar() foo().and_then(move |v| v.bar()) लिए शॉर्टहैंड होने के लिए एक तर्क होगा, ताकि परिणाम और वायदा एक ही अंकन का उपयोग कर सकें।

बस स्पष्ट होना, इस FCP question_mark सुविधा, नहीं पकड़ के बारे में है, सही है? इस अंक का शीर्षक इस एक अंक में उन दोनों विशेषताओं को ट्रैक करने से है।

@seanmonstar बाद को भी लागू नहीं किया गया है, इसलिए, हाँ। शायद अगर FCP स्वीकृति में परिणाम यह catch को ट्रैक करने के लिए बदल जाएगा।

बस स्पष्ट होना करने के लिए, यह FCP सवाल_मार्क सुविधा के बारे में है, पकड़ नहीं, सही? इस अंक का शीर्षक इस एक अंक में उन दोनों विशेषताओं को ट्रैक करने से है।

हां, बस question_mark सुविधा है।

Https://github.com/rust-lang/rfcs/issues/1718#issuecomment -241764523 पर फ़ॉलो कर रहे हैं। मैंने सोचा था कि मौजूदा व्यवहार ? को "बाइंड करंट कंटिन्यू" में सामान्यीकृत किया जा सकता है, लेकिन map_err(From::from) ? का हिस्सा इसे केवल बाइंड से थोड़ा अधिक बनाता है: /। यदि हम परिणाम के लिए From उदाहरण पूरी तरह से जोड़ते हैं, तो मुझे लगता है कि शब्दार्थ v? => from(v.bind(current-continuation)) ।

इस आंतरिक सूत्र में ? के सापेक्ष गुणों के बारे में बहुत चर्चा हुई है:

https://internals.rust-lang.org/t/the-operator-will-be-harmful-to-rust/3882/

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

मैंने पहले कोई टिप्पणी नहीं की है और शायद इस तरह से बहुत देर हो चुकी है, लेकिन मुझे लगता है कि ? ऑपरेटर को भ्रमित करने के साथ ही, अगर इसे एक छिपे हुए रिटर्न स्टेटमेंट के रूप में उपयोग किया जाता है, जैसा कि @hauleth ने चर्चा में बताया है कि आपने @ लिंक किया है @ nikomatsakis।

try! , यह स्पष्ट था कि कहीं एक वापसी हो सकती है, क्योंकि एक मैक्रो ऐसा कर सकता है। ? एक छिपे हुए return , हमारे पास फ़ंक्शन से मान वापस करने के 3 तरीके होंगे:

• निहितार्थ
• स्पष्ट वापसी
• ?

मुझे यह पसंद है, हालांकि @CryZe ने कहा:

इस तरह यह सभी के लिए जाना जाता है, यह त्रुटि को अंत तक पाइप करता है, जहां आप इसे संभाल सकते हैं, और इसका कोई निहित रिटर्न नहीं है। तो यह मोटे तौर पर इस तरह लग सकता है:

let a = try! (x? .y .z .z);

यह कोड को अधिक संक्षिप्त बनाने में मदद करता है और रिटर्न को छिपाता नहीं है। और यह अन्य भाषाओं जैसे coffeescript से परिचित है।

फ़ंक्शन स्तर के बजाय अभिव्यक्ति स्तर पर ? समाधान करने से वायदा कैसे प्रभावित होगा? अन्य सभी उपयोग के मामलों के लिए यह मेरे लिए ठीक लगता है।

मुझे यह पसंद है, हालांकि @CryZe ने कहा:

इस तरह यह सभी के लिए जाना जाता है, यह त्रुटि को अंत तक पाइप करता है, जहां आप इसे संभाल सकते हैं, और इसका कोई निहित रिटर्न नहीं है। तो यह मोटे तौर पर इस तरह लग सकता है:

let a = try! (x? .y .z .z);

मैंने इसे पोस्ट किया है। मुझे लगता है कि यह सही समाधान होगा।

कोशिश के साथ!, यह स्पष्ट था कि कहीं एक वापसी हो सकती है, क्योंकि एक मैक्रो ऐसा कर सकता है।

यह केवल स्पष्ट है क्योंकि आप जानते हैं कि जंग में मैक्रोज़ कैसे काम करते हैं। जो एक बार ? एक बार स्थिर होने जा रहा है, वह व्यापक है और Rust में प्रत्येक परिचय में समझाया गया है।

@conradkleinespel

हमारे पास फ़ंक्शन से मान लौटाने के 3 तरीके होंगे:

• निहितार्थ

जंग के पास "निहित रिटर्न" नहीं है, इसमें ऐसे भाव हैं जो एक मूल्य का मूल्यांकन करते हैं। यह एक महत्वपूर्ण अंतर है।

if foo {
    5
}

7

यदि रस्ट का "निहित प्रतिफल" होता, तो यह कोड संकलित होता। लेकिन ऐसा नहीं है, आपको return 5 ।

जो एक बार में ही सटीक होने जा रहा है? Rust में हर इंट्रो में स्थिर, व्यापक और समझाया गया है।

उदाहरण के लिए कि यह कैसा दिख सकता है, https://github.com/rust-lang/book/pull/134

कोशिश के साथ!, यह स्पष्ट था कि कहीं एक वापसी हो सकती है, क्योंकि एक मैक्रो ऐसा कर सकता है।
यह केवल स्पष्ट है क्योंकि आप जानते हैं कि जंग में मैक्रोज़ कैसे काम करते हैं। जो एक बार में ही सटीक होने जा रहा है? Rust में हर इंट्रो में स्थिर, व्यापक और समझाया गया है।

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

@hauleth

let a = try! (x? .y .z .z);

मैंने इसे पोस्ट किया है। मुझे लगता है कि यह सही समाधान होगा।

मैं दृढ़ता से असहमत हूँ। जैसा कि आपको एक जादू का प्रतीक मिलेगा जो केवल try! में काम करता है और बाहर नहीं।

@hauleth

let a = try! (x? .y .z .z);
मैंने इसे पोस्ट किया है। मुझे लगता है कि यह सही समाधान होगा।
मैं दृढ़ता से असहमत हूँ। जैसा कि आप एक जादू का प्रतीक प्राप्त करेंगे जो केवल कोशिश में काम करता है! और बाहर नहीं।

मैंने यह नहीं कहा है कि ? को केवल try! में ही काम करना चाहिए। जो मैं कह रहा था कि ? को पाइप ऑपरेटर की तरह काम करना चाहिए जो डेटा को स्ट्रीम में वापस लाएगा और जैसे ही यह होता है, त्रुटि वापस कर देगा। उस मामले में try! आवश्यकता नहीं होगी, लेकिन इसे उसी संदर्भ में उपयोग किया जा सकता है, जैसा कि अब उपयोग किया जाता है।

@steveklabnik मुझे लगता है कि जंग के कारण निहित प्रतिफल के रूप में, आपके उदाहरण में, 5 निहित रूप से वापस नहीं किया गया था, लेकिन यह लेने देता है:

fn test() -> i32 {
    5
}

यहाँ, 5 का निहितार्थ है, है ना? जैसा कि आपके उदाहरण में return 5; विरोध होगा। यह मान लौटाने के 2 अलग-अलग तरीकों के लिए बनाता है। जो मुझे रस्ट के बारे में कुछ भ्रामक लगता है। तीसरा जोड़ने से आईएमओ को मदद नहीं मिलेगी।

यह नहीं। यह एक अभिव्यक्ति का परिणाम है, विशेष रूप से, फ़ंक्शन बॉडी। "निहित प्रतिफल" का तात्पर्य है कि आप किसी तरह से कहीं से भी वापसी कर सकते हैं, लेकिन यह सच नहीं है। कोई अन्य अभिव्यक्ति-आधारित भाषा इसे "निहित प्रतिफल" नहीं कहती, जैसा कि ऊपर मेरे कोड नमूने में होगा।

@steveklabnik ठीक है, इसे समझाने के लिए समय निकालने के लिए धन्यवाद: +1:

यह सब अच्छा है! मैं पूरी तरह से देख सकता हूं कि आप कहां से आ रहे हैं, यह सिर्फ दो अलग-अलग चीजें हैं जो लोग अक्सर गलत तरीके से उपयोग करते हैं। मैंने लोगों को "निहित प्रतिफल" ग्रहण करते देखा है इसका मतलब है कि आप वापस लौटने के लिए स्रोत में कहीं भी ; छोड़ सकते हैं .... कि _would_ बहुत बुरा: मुस्कुराएं:

@ उलेथ ? ऑपरेटर उस मामले में and_then के लिए सिंटैक्टिक शुगर होगा। इस तरह से आप इसे बहुत अधिक मामलों में उपयोग कर सकते हैं और इसे वापस लौटने के लिए कठिन नहीं होना पड़ेगा। यह भी है कि अन्य सभी भाषाओं में क्या है? ऑपरेटर। जंग की? वर्तमान कार्यान्वयन में ऑपरेटर अन्य सभी भाषाओं का सटीक प्रदर्शन होगा। इसके अलावा_ यह क्रियात्मक दृष्टिकोण है और इसे वैसे भी प्रोत्साहित किया जाता है, क्योंकि इसमें स्पष्ट नियंत्रण प्रवाह होता है। तो बस बना रहे हो? and_then के लिए सिंथेट्रिक शुगर और फिर वर्तमान कोशिश को बनाए रखना! स्पष्ट रूप से "अलिखित और वापस लौटने" के लिए, अधिक साफ स्थिति प्रतीत होती है, जिससे रिटर्न अधिक दिखाई देता है और? ऑपरेटर अधिक लचीला (पैटर्न मिलान जैसे गैर-रिटर्न मामलों में इसका उपयोग करने में सक्षम होने से)।

बिल्कुल सही।

Łुकाज़ नीमियर
[email protected]

Wiadomo Christć napisana przez क्रिस्टोफर सेर सूचनाएं @github.com w dniu 02.09.2016, ओ गॉडज़। 21:05:

@hauleth https://github.com/hauleth द? ऑपरेटर उस मामले में and_then के लिए सिंटैक्टिक शुगर होगा। इस तरह से आप इसे बहुत अधिक मामलों में उपयोग कर सकते हैं और इसे वापस लौटने के लिए कठिन नहीं होना पड़ेगा। यह भी है कि अन्य सभी भाषाओं में क्या है? ऑपरेटर। जंग की? वर्तमान कार्यान्वयन में ऑपरेटर अन्य सभी भाषाओं का सटीक प्रदर्शन होगा। इसके अलावा_ यह क्रियात्मक दृष्टिकोण है और इसे वैसे भी प्रोत्साहित किया जाता है, क्योंकि इसमें स्पष्ट नियंत्रण प्रवाह होता है। तो बस बना रहे हो? and_then के लिए सिंथेट्रिक शुगर और फिर वर्तमान कोशिश को बनाए रखना! स्पष्ट रूप से "अलिखित और वापस लौटने" के लिए, अधिक साफ स्थिति प्रतीत होती है, जिससे रिटर्न अधिक दिखाई देता है और? ऑपरेटर अधिक लचीला (पैटर्न मिलान जैसे गैर-रिटर्न मामलों में इसका उपयोग करने में सक्षम होने से)।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub https://github.com/rust-lang/rust/issues/31436#issuecomment -244461722 पर https://github.com/notifications-unsubscribe-auth/ पर म्यूट

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

@steveklabnik हम इसे "अंतर्निहित वापसी" कहते हैं, क्योंकि हम नहीं कर रहे हैं केवल लोगों को ।

रूह के मेरे सभी वर्षों में

मैंने कुछ प्रोजेक्ट्स में ? किया है और इसे try! , क्योंकि यह पोस्टफ़िक्स की स्थिति में है। सामान्य तौर पर, "वास्तविक" रस्ट कोड बहुत अधिक Result 'मोनाड' main और कभी-कभी पत्ती के नोड्स को छोड़कर इसे कभी नहीं छोड़ता है; और ऐसे कोड से हमेशा त्रुटियों के प्रचार की उम्मीद की जाती है। अधिकांश भाग के लिए यह कोई फर्क नहीं पड़ता कि कौन सी अभिव्यक्तियाँ त्रुटियां पैदा कर रही हैं - वे सभी केवल स्टैक अप वापस भेजे जा रहे हैं, और मैं यह नहीं देखना चाहता कि जब मैं कोड के मुख्य तर्क के माध्यम से पढ़ रहा हूं।

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

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

जैसे कि मैं ? को स्थिर करने के लिए एक बहुत बड़ा +1 देता हूं, जिसका नाम Carrier विशेषता के आधार पर है, जो आदर्श रूप से कुछ अन्य मामलों को भी कवर करता है, जिन्हें मैं इसके बारे में अन्य चर्चा में लाया था।

मेरी मुख्य चिंता के साथ? यह है कि मुझे वही लाभ मिल सकता है - उपसर्ग की स्थिति - विधि मैक्रोज़ के साथ, यदि वे मौजूद थे।

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

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

इसके लिए बहुत चर्चा के साथ _is_
RFC के विलय से पहले ? बहुत चर्चा की गई है, और एक समर्थक के रूप में यह उसी तरह का थका देने वाला है जब स्थिरीकरण पर चर्चा की जाती है।

वैसे भी, मैं अपने +1 को @mitsuhiko की भावनाओं के लिए यहाँ

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

क्षमा करें, मेरी टिप्पणी बहुत संक्षिप्त थी। मैं कुछ प्रकार के "मेक्रोस" के लिए एक RFC बनाने की बात कर रहा था, उदाहरण के लिए func1().try!().func2().try!() (जहाँ तक मुझे पता है, यह वर्तमान में संभव नहीं है)।

व्यक्तिगत रूप से मुझे पसंद है? ऑपरेटर, लेकिन मैं @brson जैसी ही चिंताओं को साझा करता @nikomatsakis से जुड़ा हुआ है, निश्चित रूप से इस सुविधा के बारे में अभी भी कुछ विवाद है, भले ही यह बार-बार एक ही तर्क हो। हालांकि अगर कोई व्यवहार्य विकल्प नहीं हैं, तो स्थिर करना सबसे अधिक समझ में आता है।

यह पूरी तरह से लागू किए बिना किसी विशेषता को स्थिर करने के लिए समय से पहले लगता है - इस मामले में, पकड़ {..} अभिव्यक्ति।

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

@mcpherrinm अन्य भाषाओं में त्रुटि से निपटने के लिए हर कॉल पर operator() को "सशर्त वापसी ऑपरेटर" कहेंगे?

जटिलता बजट के रूप में, यह केवल try! से सिंटैक्टिक रूप से भिन्न है, कम से कम वह हिस्सा जिसके बारे में आप शिकायत कर रहे हैं।
क्या try! -हाय कोड के खिलाफ तर्क, जो ? केवल अधिक पठनीय बनाता है?
यदि ऐसा है, तो मैं सहमत हूँ कि अगर "कोई त्रुटि प्रसार स्वचालन _at all_" के अलावा कोई गंभीर विकल्प नहीं है।

एक समझौता सुझाना: https://github.com/rust-lang/rfcs/pull/1737

यह स्वीकार किए जाने की कोई संभावना नहीं हो सकती है, लेकिन मैं वैसे भी कोशिश कर रहा हूं।

मैं "विधि मैक्रोज़" के बारे में @keeperofdakeys के विचार को पसंद करता ? सिंटैक्स को उसी कारण के लिए स्वीकार किया जाना चाहिए क्योंकि टर्नरी ऑपरेटर जंग में नहीं है - पठनीयता। ? स्वयं कुछ भी नहीं कहता है। इसके बजाय, मैं बहुत "मेक्रोस" के साथ ? के व्यवहार को सामान्य करने की क्षमता देखूंगा।

a.some_macro!(b);
// could be syntax sugar for
some_macro!(a, b); 

a.try!();
// could be syntax sugar for
try!(a); 

इस तरह, यह स्पष्ट होगा कि व्यवहार क्या है, और यह आसान जंजीरों की अनुमति देता है।

विधि मैक्रो result.try!() भाषा एर्गोनॉमिक्स के लिए एक अधिक सामान्य सुधार प्रतीत होता है और एक नए ? ऑपरेटर की तुलना में कम तदर्थ लगता है।

@brson

मेरी अन्य चिंताएँ हैं कि शायद वर्तमान फॉर्मूले को स्थिर करके हम एरर हैंडलिंग में भविष्य की स्पष्टता को सीमित कर रहे हैं - वर्तमान परिणाम रूपांतरण रूस्तम में एरर हैंडलिंग में त्रुटि से निपटने के लिए पर्याप्त नहीं है जैसा कि मैं चाहूंगा

यह एक दिलचस्प बिंदु है। यह इस पर कुछ केंद्रित समय बिताने के लायक होगा (शायद आप और मैं थोड़ा चैट कर सकते हैं)। मैं मानता हूं कि हम यहां बेहतर कर सकते थे। Carrier विशेषता के लिए प्रस्तावित डिज़ाइन (देखें https://github.com/rust-lang/rfcs/issues/1718) यहाँ मदद कर सकते हैं, खासकर अगर विशेषज्ञता के साथ संयुक्त, क्योंकि यह चीजों को और अधिक लचीला बनाता है।

मुझे वास्तव में संदेह है कि मैक्रोज़ भाषा के लिए एक अच्छा विस्तार होगा।

macro_rules! मैक्रोस वर्तमान में फ़ंक्शनल फ़ंक्शंस के लिए एक समान तरीके से घोषित किए जाते हैं, और तब और भी अनुरूप हो जाएंगे जब उनके लिए नया आयात सिस्टम अपनाया जाएगा। मेरा मतलब यह है कि उन्हें शीर्ष स्तर की वस्तुओं की तरह घोषित किया गया है और शीर्ष स्तर की वस्तुओं की तरह ही आमंत्रित किया गया है, और जल्द ही उन्हें शीर्ष स्तर की वस्तुओं की तरह आयात किया जाएगा।

यह नहीं है कि कैसे तरीके काम करते हैं। विधियों में ये गुण हैं:

1. मॉड्यूल दायरे में घोषित नहीं किया जा सकता है, लेकिन impl ब्लॉक के भीतर घोषित किया जाना चाहिए।
2. प्रकार के साथ आयात किया जाता है / सीधे impl ब्लॉक के साथ जुड़ा होता है, बजाय सीधे आयात किया जाता है।
3. इस दायरे में एकल, असंदिग्ध प्रतीक होने के आधार पर भेजे जाने के बजाय उनके रिसीवर प्रकार के आधार पर भेजे जाते हैं।

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

इन कारणों से मुझे नहीं लगता कि ? देरी के लिए यह एक अच्छा विकल्प है कि" विधि मैक्रोज़ "किसी दिन प्रकट हो सकता है।

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

@ उलेथ , @ क्रायज़े

यह सुझाव देने वालों को जवाब देने के लिए कि ? का and_then ऑपरेटर होना चाहिए, यह कोटलिन जैसी भाषाओं में अच्छी तरह से काम करता है (मैं coffeescript से परिचित नहीं हूं) उनके विस्तार कार्यों के व्यापक उपयोग के कारण लेकिन यह नहीं है जंग में इतना सीधा। असल में, and_then अधिकांश उपयोग maybe_i.and_then(|i| i.foo()) , वे maybe_i.and_then(|i| Foo::foo(i)) , पूर्व को maybe_i?.foo() रूप में व्यक्त किया जा सकता है, लेकिन बाद वाला नहीं हो सकता। कोई यह कह सकता है कि Foo::foo(maybe_i?, maybe_j?) maybe_i.and_then(|i| maybe_j.and_then(|j| Foo::foo(i, j))) में बदल जाता है, लेकिन यह कहने से भी अधिक भ्रामक लगता है कि जंग पहले ? टकराने पर वापसी करता है जो एक त्रुटि का मूल्यांकन करता है। हालाँकि, यह यकीनन अधिक शक्तिशाली होगा।

@Stebalien स्वीकृत RFC में, catch { Foo::foo(maybe_i?, maybe_j?) } वह करता है जो आप चाहते हैं।

@ हेड्डी गुड पॉइंट। मुझे लगता है कि मैं "हालांकि, यह यकीनन अधिक शक्तिशाली होगा" छोड़ सकता है। यह निहित कैच / स्पष्ट प्रयास बनाम स्पष्ट कैच / निहित प्रयास के लिए नीचे आता है:

let x: i32 = try Foo::foo(a?.b?.c()?));
let y: Result<i32, _> = Foo::foo(a?.b?.c()?);

बनाम:

let x: i32 = Foo::foo(a?.b?.c()?);
let y: Result<i32, _> = catch  Foo::foo(a?.b?.c()?);

(मोडुलो सिंटैक्स)

@Stebalien एक अन्य उदाहरण: यदि मैं Foo एक फ़ंक्शन के लिए bar पास करना चाहता था, तो आपके प्रस्ताव के साथ मुझे इसकी आवश्यकता होगी:

bar(Foo::foo(a?.b?.c()?)?)

क्या यह आपके दिमाग में है? अतिरिक्त ध्यान दें ? , इसके बिना bar एक मिलेगा Result एक के बजाय Foo ।

@ हेड्डी शायद। नोट: मैं वास्तव में यह प्रस्ताव नहीं कर रहा हूँ! मैं तर्क दे रहा हूं कि पाइप-ऑपरेटर के रूप में ? का उपयोग करना Foo::foo(bar?) मामले को संभालने के लिए किसी तरह से जंग के बिना विशेष रूप से उपयोगी नहीं है।

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

@Stebalien , ? रूप में पाइप ऑपरेटर Foo::foo(bar?) इस तरह दिखेगा: Foo::foo(try!(bar)) और bar(Foo::foo(a?.b?.c()?)?) ( Foo::foo : fn(Result<_, _>) -> Result<_, _> मानते हुए): bar(try!(Foo::foo(a?.b?.c()?))) ।

@ मेरी बात यह थी कि Foo::foo(bar?)? _much_ जंग में bar?.foo()? से अधिक आम है। इसलिए, उपयोगी होने के लिए, ? को इस मामले का समर्थन करना होगा (या किसी अन्य सुविधा को पेश करना होगा)। मैं ऐसा करने का एक तरीका पोस्ट कर रहा था और यह दिखा रहा था कि यह तरीका कम से कम गड़बड़ होगा। ? का संपूर्ण बिंदु try!(foo(try!(bar(try!(baz()))))) (2x कोष्ठक!) लिखने से बचने में सक्षम होना है; यह आमतौर पर try!(baz()?.bar()?.foo()) रूप में इसे फिर से लिखना संभव नहीं है।

लेकिन आप हमेशा ऐसा कर सकते हैं:

try!(baz().and_then(bar).and_then(foo))

Łुकाज़ नीमियर
[email protected]

Wiadomo Steć napisana przez स्टीवन एलेन नोटिफिकेशन @github.com w dniu 05.09.2016, ओ गॉडज़। 15:39:

@hauleth https://github.com/hauleth मेरी बात यह थी कि फू: फू (बार?)? बार की तुलना में अधिक सामान्य है? .foo () जंग में। इसलिए, उपयोगी होने के लिए,? इस मामले का समर्थन करना होगा (या किसी अन्य सुविधा को पेश करना होगा)। मैं ऐसा करने का एक तरीका पोस्ट कर रहा था और यह दिखा रहा था कि यह तरीका कम से कम गड़बड़ होगा। के पूरे बिंदु? लिखने की कोशिश से बचने में सक्षम होने के लिए है! (फू (कोशिश! (बार (कोशिश! ()))))) (2x कोष्ठक!)। यह आमतौर पर कोशिश के रूप में इसे फिर से लिखना संभव नहीं है! (baz () ?. बार ()? फू ())।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub https://github.com/rust-lang/rust/issues/31436#issuecomment -244749275 पर https://github.com/notifications-unsubscribe-auth/ देखें AARzN1Hdk6uk5-SoYawtgAbJUDf_8MsMks5qnBumgaJpZM4HUm_-।

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

https://github.com/colin-kiegel/rust-derive-builder/issues/25

विधि मैक्रो विचार @nrc और @withoutboats पर आपके विचारों के लिए धन्यवाद, कुछ ठोस कारणों को सुनने के लिए अच्छा है कि वे काम क्यों नहीं करेंगे।

@ हनीसेल मैं यह कहना सही नहीं समझता कि ? "मुख्य रूप से" बिल्डरों द्वारा उपयोग किया जा रहा है। जबकि बिल्डर्स एक उदाहरण हैं जहां मुझे लगता है कि एक हल्के, पोस्टफिक्स ऑपरेटर का लाभ वास्तव में चमकता है, मैं हर संदर्भ में ? से try! को प्राथमिकता देता हूं।

@ वायदा वायदा के संबंध में, मैं मूल रूप से इसी तरह के कारणों के लिए चिंतित था। लेकिन, इसके बारे में सोचने के बाद, मुझे लगता है कि async / await उस संदर्भ में ? की किसी भी ज़रूरत को पूरा करेगा। वे वास्तव में काफी ओर्थोगोनल हैं: आप (await future)?.bar() जैसी चीजें कर सकते थे।

(शायद कीवर्ड await बजाय एक प्रत्यय ऑपरेटर होना अच्छा होगा, ताकि parens आवश्यक न हों। या शायद एक ध्यान से देखते हुए वरीयता पर्याप्त होगी।)

इससे पहले कि हम स्थिर हों, मैं निश्चित रूप से लिखे गए कुछ दस्तावेज़ देखना चाहूंगा। मैंने संदर्भ में देखा और कोई उल्लेख नहीं पाया। हमें इस सुविधा का दस्तावेज कहां देना चाहिए?

@ मुझे पता है कि @steveklabnik आम तौर पर अस्थिर सुविधाओं के दस्तावेज़ीकरण से बचता है, क्योंकि यह मौका है कि यह समय की बर्बादी होगी यदि वे कभी स्थिर नहीं होते हैं। मुझे नहीं पता कि क्या हमने पहले कभी दस्तावेज लेखन पर स्थिरीकरण को अवरुद्ध किया है।

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

मुझे लगता है कि इस RFC का महत्वपूर्ण हिस्सा अभिव्यक्ति के दाईं ओर का कुछ होना है जो try! तरह काम करता है, क्योंकि यह "कोशिश" _much_ अधिक पठनीय और "पकड़ने" के लिए अनुक्रमिक / जंजीर पढ़ता है। । मूलतः मैं ? वाक्यविन्यास के रूप में उपयोग करने के लिए 100% समर्थक था, लेकिन हाल ही में मैंने कुछ (साफ!) कोड को पहले ही ? का उपयोग करके ठोकर खाई जिससे मुझे पता चला कि सरल उदाहरण ? से बाहर है! । जो अब मुझे विश्वास दिलाता है कि "नई कोशिश" के लिए वाक्यविन्यास के रूप में ? का उपयोग करना एक बड़ी गलती हो सकती है।

इसलिए मैं यह प्रस्तावित करता हूं कि इसे अंतिम रूप देने के लिए कुछ पोल_ करने के लिए एक अच्छा विचार हो सकता है_ इसे अंतिम रूप देने से पहले (फ़ोरम पर इसके बारे में अधिसूचना के साथ) सिंटेक्स के रूप में ? या किसी अन्य प्रतीक (s) का उपयोग करने के बारे में फीड-बैक प्राप्त करने के लिए। । एक लंबे फ़ंक्शन में उपयोग के उदाहरण के साथ वैकल्पिक रूप से। ध्यान दें कि मैं केवल इस बात पर विचार कर रहा हूं कि ? का नाम बदलने के लिए यह एक अच्छा विचार हो सकता है कि कुछ और न बदले। सर्वेक्षण में उन अन्य नामों की सूची दी जा सकती है जो अतीत में ?! (या ?? ) या केवल "उपयोग? बनाम चरित्र की तुलना में अधिक उपयोग करते हैं" जैसे किसी चीज़ को सूचीबद्ध करते थे।

Btw। ? का उपयोग न करने से उन लोगों को भी संतुष्ट किया जा सकता है जो इसे पसंद नहीं करते हैं क्योंकि यह अन्य भाषाओं के वैकल्पिक प्रकार के समान सिंटैक्स है। और जो इसे जंग विकल्प के लिए एक वैकल्पिक वाक्यविन्यास बनाना चाहते हैं। (इसके माध्यम से मेरे द्वारा साझा की जाने वाली चिंताएं नहीं हैं)।

इसके अतिरिक्त, मुझे लगता है कि ऐसे पोल वाले लोग सामान्य रूप से RFC प्रक्रिया में भाग नहीं ले सकते। आम तौर पर इसकी आवश्यकता नहीं हो सकती है, लेकिन try! => ? किसी भी लेखन और / या रीडिंग कोड के लिए एक बहुत बड़ा परिवर्तन है।

पुनश्च:
मैंने विभिन्न प्रकारों ("?", "?", "," ?? ") में उपरोक्त पसंद किए गए फ़ंक्शन के साथ एक जिस्ट लगा दिया। मुझे पता नहीं है कि क्या अधिक था। इसके अलावा ? ?! नाम बदलने के लिए एक RFC था जिसे इस चर्चा में पुनर्निर्देशित किया गया था।

क्षमा करें, संभव है कि पहले से चली आ रही चर्चा को फिर से शुरू करने के बारे में: smiley_cat:।

(ध्यान दें कि ?? अगर आप अभी भी लागू करने के लिए चाहते हैं बुरा है ? विकल्प के लिए क्योंकि expr??? अस्पष्ट होगा)

? बेहद आसान अनदेखी है

हम यहां क्या चर्चा कर रहे हैं? पूरी तरह से unhighlighted कोड? नियमित रूप से हाइलाइट किए गए कोड ब्राउज़िंग?
या सक्रिय रूप से एक फ़ंक्शन में ? की तलाश कर रहे हैं?

अगर मैं अपने संपादक में एक ? का चयन करता हूं, तो _all_ फ़ाइल में अन्य ? को एक चमकीले पीले रंग की पृष्ठभूमि के साथ हाइलाइट किया जाता है, और खोज फ़ंक्शन भी काम करता है, इसलिए मुझे ऐसा नहीं लगता है मेरे लिए _any_ कठिनाई के रूप में प्रस्तुत करना।

अन्य मामलों के लिए, मैं इसके बजाय ?? या ?! साथ बेहतर हाइलाइटिंग द्वारा हल करूंगा।

@dathinab मुझे लगता है कि .try! () या कुछ और भी बेहतर होगा, लेकिन इसके लिए मैक्रोज़ के लिए UFCS की आवश्यकता होगी।

let namespace = namespace_opt.ok_or(Error::NoEntry).try!();

इस तरह यह याद रखना मुश्किल है, लेकिन बस के रूप में आसान है, अगर .unwrap() से अधिक आसान भी नहीं है।

@ हेड्डी : यह सामान्य हाइलाइट किए गए कोड के बारे में है, जैसे ? आसानी से नजरअंदाज न करने के लिए मजबूत हाइलाइटिंग की आवश्यकता होती है, जो दोनों एक और रिटर्न पथ (/ पकड़ने का पथ) और संभव रूप से Result<T> से एक चर के प्रकार को बदल देगा। T

@CryZe : मैं .try!() से थोड़ा कम है, इतना बुरा भी नहीं है।

@CryZe मुझे वह वाक्य रचना भी पसंद है, लेकिन @withoutboats ने कुछ ठोस कारणों का उल्लेख किया कि विधि मैक्रोज़ भाषा को चोट क्यों पहुंचा सकती है।
दूसरी तरफ, मुझे डर है कि अगर मैक्रोज़ दिखाई देते हैं, तो मुझे नहीं लगता कि वे ? साथ अच्छा खेलेंगे।

मैं स्वाभाविक रूप से इस सजगता के लिए दो वर्णों का उपयोग करने के खिलाफ नहीं हूं, लेकिन मैंने उदाहरणों को देखा और मैंने पाया कि ? किए गए परिवर्तन मेरे लिए कोई भी दृश्यमान नहीं हैं।

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

@CryZe : शायद ?try जैसा कुछ कीवर्ड की तरह होगा। लेकिन ईमानदार होने के लिए मुझे यह पसंद नहीं है ( ?try )।

@eddyb

और खोज फ़ंक्शन भी काम करता है

? की खोज करने से झूठी सकारात्मकता बढ़ेगी, जबकि लंबे समय तक संस्करणों की संभावना नहीं होगी।

के लिए खोज ? झूठे सकारात्मक को चालू करेगा, जबकि अधिक समय तक संस्करणों की संभावना नहीं होगी।

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

उदाहरण के लिए,

वाह जो निश्चित रूप से बहुत मदद करता है। लेकिन फिर आपको वास्तव में आपको यह सुनिश्चित करने की आवश्यकता है
आपके संपादक ने ठीक से कॉन्फ़िगर किया है, जिसे आप हर समय (जैसे) नहीं कर सकते
उदाहरण के लिए GitHub पर)।

2016-09-15 23:52 GMT + 02: 00 स्टीवन एलन सूचनाएं @github.com:

उदाहरण के लिए,
[छवि: स्क्रीन-२०१६-०९ -१५-१13५१३१]
https://cloud.githubusercontent.com/assets/310393/18568833/1deed796-7b6d-11e6-99af-75f0d7ddd778.png

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/rust-lang/rust/issues/31436#issuecomment -247465972,
या धागा म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABYmbjyrt07NXKMUdmlBfaciRZq7uBVEks5qqb4sgaJpZM4HUm_-
।

@CryZe मुझे पूरा यकीन है कि GitHub सिर्फ कुछ खुले स्रोत वाक्यविन्यास हाइलाइटर का उपयोग कर रहा है; हम इसे पैच कर सकते हैं :-)

मुझे लगता है कि सामान्य तौर पर रस्ट परियोजना के लिए यह एक अच्छा विचार है कि सिफारिश करें कि जंग के लिए सिंटैक्स हाइलाइटर्स दृश्यता के बारे में चिंताओं को संतुलित करने के लिए ? पर अत्यधिक दृश्य शैली का उपयोग करें।

मुझे लगता है कि ? सबसे अच्छा विकल्प है जिसे हम यहां बना सकते हैं, और हम इसे मिरी में बहुत अधिक उपयोग कर रहे हैं।

मूल प्रेरणा के लिए वापस सुनकर, try!(...) अप्रभावी है और त्रुटियों के प्रवाह को अनदेखा करना मुश्किल बना देता है और बस खुश-पथ को पढ़ता है। यह पारंपरिक भाषाओं के अदृश्य अपवादों की तुलना में एक नकारात्मक पहलू है। अधिक शामिल कीवर्ड में ? का विस्तार एक ही नकारात्मक पहलू होगा।

दूसरी ओर, ? , जब मुझे त्रुटियों के प्रवाह की परवाह नहीं होती है तो मैं इसे अनदेखा कर सकता हूं और इसे पृष्ठभूमि में फीका कर सकता हूं। और जब मैं वास्तव में त्रुटियों के प्रवाह के बारे में परवाह करता हूं, तो मैं अभी भी ? ठीक देख सकता हूं। ? हाइलाइटिंग मेरे लिए भी आवश्यक नहीं है, लेकिन अगर यह अन्य लोगों की मदद करता है, तो यह बहुत अच्छा है। यह अदृश्य अपवादों और try! दोनों पर एक सुधार है।

?! जैसे तुच्छ रूप से बड़े सर्जिल पर स्विच करने से मुझे किसी भी तरह से सहायता नहीं मिलेगी, लेकिन कोड पढ़ना और लिखना त्रुटि को मामूली रूप से बदतर बना देगा।

हार्दिक अंतिम टिप्पणी की अवधि (साथ ही एक पूर्व इंटर्न्स थ्रेड ) के लिए सभी को धन्यवाद। यह देखते हुए कि हम आज तक की

मुझे पहले पीछा करने में कटौती करने दें: @ जंग-लंग / लंग टीम ने Result प्रकार के मूल्यों पर लागू होने पर ? ऑपरेटर को स्थिर करने का निर्णय लिया है। ध्यान दें कि catch फ़ीचर को स्थिर नहीं किया जा रहा है (और, वास्तव में, अभी तक लागू नहीं हुआ है); इसी तरह, तथाकथित "वाहक विशेषता" है, जो एक साधन है विस्तार करने के लिए ? की तरह प्रकार के लिए Option , है पूर्व आरएफसी चर्चा चरण में अभी भी । हालांकि हमने वर्तमान कार्यान्वयन में यह सुनिश्चित करने के लिए कदम उठाए हैं कि हम बाद में Carrier विशेषता जोड़ सकें (जो कि अनुमान के साथ संभावित इंटरैक्शन के बारे में मेरी पहले की कुछ चिंताओं को संबोधित करते हैं)।

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

? ऑपरेटर का दायरा वर्तमान अभिव्यक्ति होना चाहिए, न कि वर्तमान फ़ंक्शन।

जब कोई त्रुटि होती है, तो आज का try! मैक्रो उस त्रुटि को बिना कॉलिंग फ़ंक्शन के लिए प्रचारित करता है (दूसरे शब्दों में, यह return त्रुटि के साथ निष्पादित करता है)। जैसा कि वर्तमान में डिज़ाइन किया गया है, ? ऑपरेटर इस मिसाल का पालन करता है, लेकिन catch कीवर्ड का समर्थन करने के इरादे से, जो उपयोगकर्ता को अधिक सीमित दायरे को निर्दिष्ट करने की अनुमति देता है। इसका मतलब है, उदाहरण के लिए, कि x.and_then(|b| foo(b)) catch { foo(x?) } रूप में लिखा जा सकता है। इसके विपरीत, कई हालिया भाषाओं में ? ऑपरेटर का उपयोग and_then लिए और अधिक अनुरूप करने के लिए किया जाता है।

अंततः, एक बार catch लागू होने के बाद, यह चूक का प्रश्न है । और वहाँ कई कारणों से हम मानते हैं कि यह है कि "समारोह से बाहर तोड़" (अनुकूलित करने के लिए विकल्प के साथ) के डिफ़ॉल्ट के लिए अधिक उपयुक्त है कर रहे हैं ? जंग में:

• try! मैक्रो ने बहुत उपयोगी डिफ़ॉल्ट के रूप में कई बार खुद को साबित किया है । ? try! प्रतिस्थापन के रूप में अभिप्रेत है, इसलिए इसका व्यवहार करना स्वाभाविक है।
• रस्ट में ? मुख्य रूप से परिणामों के प्रचार के लिए उपयोग में है, जो अपवादों के अधिक अनुरूप है। सभी अपवाद सिस्टम मौजूदा फ़ंक्शन से बाहर और कॉलर में (यहां तक ​​कि जो स्विफ्ट की तरह, ऐसा करने के लिए भी एक कीवर्ड की आवश्यकता होती है) त्रुटियों को फैलाने के लिए डिफ़ॉल्ट होते हैं।
  
  
  
  • इसके विपरीत, स्विफ्ट, ग्रूवी में ? और इसके बाद शून्य मान या विकल्प प्रकारों के साथ क्या करना है।
  
  
  • अगर हम एक वाहक विशेषता को अपनाते हैं, तो Rust में ? ऑपरेटर अभी भी उक्त परिदृश्यों (और विशेष रूप से catch के साथ संयोजन में) का उपयोग किया जा सकता है, लेकिन यह _main_ उपयोग मामला नहीं है।
  
  
• Rust में and_then कई उपयोग आज विधि संकेतन का उपयोग करके काम नहीं करेंगे ; कुछ भविष्य के उपयोग (जैसे कि वायदा में) किसी भी मामले में एक async- प्रतीक्षित परिवर्तन से कम हो सकते हैं

? अस्पष्ट नियंत्रण प्रवाह है क्योंकि यह स्पॉट करना मुश्किल है।

एक सामान्य चिंता यह है कि ? ऑपरेटर को अनदेखा करना बहुत आसान है । यह स्पष्ट रूप से एक संतुलन कार्य है। लाइटवेट ऑपरेटर होने से "खुश पथ" पर ध्यान केंद्रित करना आसान हो जाता है जब आप चाहते हैं - लेकिन यह महत्वपूर्ण है कि कुछ संकेत हों कि त्रुटियां कहां हो सकती हैं (अपवादों के विपरीत, जो अंतर्निहित नियंत्रण-प्रवाह का परिचय देते हैं)। इसके अलावा, सिंटैक्स हाइलाइटिंग (जैसे, 1 , 2 ) के माध्यम से ? आसान बनाना आसान है।

मैक्रोज़ का तरीका क्यों नहीं?

? के बड़े लाभों में से एक यह है कि इसे पोस्ट-फिक्स स्थिति में उपयोग किया जा सकता है, लेकिन
हम foo.try! जैसे "विधि मैक्रोज़" से समान लाभ प्राप्त कर सकते हैं । जबकि सच है, विधि मैक्रोज़ स्वयं बहुत जटिलता खोलते हैं , खासकर यदि आप चाहते हैं कि वे तरीकों की तरह व्यवहार करें (जैसे, रिसीवर के प्रकार के आधार पर भेजा गया है, और शाब्दिक गुंजाइश का उपयोग नहीं करते हैं)। इसके अलावा, foo.try! की तरह एक मैक्रो का उपयोग करने से foo? (पिछले बिंदु देखें) की तुलना में काफी भारी वजन महसूस होता है।

क्या अनुबंध From प्रस्ताव होना चाहिए?

मूल RFC चर्चा में, हमने From लिए [चाहे "अनुबंध" होना चाहिए, के सवाल को स्थगित करने का फैसला किया ((https://github.com/rust-lang/rust/issues/31436#issuomomment) -180558025) lang टीम की आम सहमति यह है कि किसी को ? ऑपरेटर को From विशेषता के रूप में देखना चाहिए , और यह कि From लक्षण स्वाभाविक रूप से जो कुछ भी कर सकते हैं को उनके प्रकार के हस्ताक्षरों द्वारा अनुमति दी जाती है। ध्यान दें कि From विशेषता की भूमिका वैसे भी यहाँ काफी सीमित है: इसका उपयोग बस एक प्रकार की त्रुटि से दूसरे में परिवर्तित करने के लिए किया जाता है (लेकिन हमेशा Result के संदर्भ में।

हालाँकि , मैं यह नोट करना चाहूंगा कि एक "वाहक" विशेषता के बारे में चर्चा चल रही है , और उस परिदृश्य में मजबूत सम्मेलनों को अपनाना अधिक महत्वपूर्ण है । विशेष रूप से, वाहक गुण को परिभाषित करता है कि एक प्रकार के लिए "सफलता" और "विफलता" का गठन क्या होता है, साथ ही साथ एक प्रकार का मूल्य (जैसे, एक Option ) को दूसरे में बदला जा सकता है (जैसे, एक Result )। कई लोगों ने तर्क दिया है कि हम "त्रुटि-जैसे" प्रकारों (जैसे, ? के बीच Option को Result ) में परिवर्तित करने में सक्षम नहीं होना चाहिए, के बीच के अंतरविरोधों का समर्थन नहीं करना चाहते हैं । जाहिर है, चूंकि एंड-यूजर्स अपने स्वयं के प्रकारों के लिए Carrier विशेषता को लागू कर सकते हैं, क्योंकि यह अंततः एक दिशानिर्देश है, लेकिन मुझे लगता है कि यह एक महत्वपूर्ण है।

बंदरगाह की कोशिश! उपयोग करने के लिए ?

मुझे नहीं लगता कि हम कभी भी इसे पीछे की ओर मज़बूती से कर सकते हैं और हमें try! का कार्यान्वयन अकेले छोड़ देना चाहिए। क्या हमें try! घटाना चाहिए?

@nrc यह पिछड़े संगत क्यों नहीं है?

@withoutboats try!(x) (x : Result<_, _>)? और हम शायद इसे वैसे ही लागू कर सकते हैं यदि हम _wanted_ करते हैं, लेकिन सामान्य रूप से x? किसी भी चीज़ का अनुमान लगा सकते हैं जो Carrier समर्थन करती है विशेषता (भविष्य में), एक उदाहरण iter.collect()? जो try! केवल Result लेकिन वास्तविक रूप से Option ।

यह समझ आता है। मुझे लगा कि हमने स्वीकार किया है कि एसटीडी में इम्प्लॉइज जोड़ने से इंफ़िगमेंट अस्पष्टता हो सकती है; यहाँ भी स्वीकार क्यों नहीं?

किसी भी तरह से, मुझे लगता है कि try! को पदावनत किया जाना चाहिए।

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

@ est31 वे वास्तव में एक ही काम करते हैं, सिवाय अनुमान के। यकीन नहीं है कि आप वास्तव में क्या मतलब है, लेकिन ? आमतौर पर सख्ती से क्लीनर (फिर से modulo इंजेक्शन) है। क्या आप उदाहरण दे सकते हैं?

@eddyb foo()?.bar()?.baz() try!(try!(foo()).bar()).baz() , और try!(bar(try!(foo()))) bar(foo()?)?

मुझे दोनों मामलों में ? अधिक पठनीय लगता है। यह अनावश्यक कोष्ठक अव्यवस्था को कम करता है।

यह जमीन कब स्थिर होगी?

@ofek यह पूरी बात के लिए है, जो अभी पूरी नहीं हुई है, इसलिए यह कहना मुश्किल है। https://github.com/rust-lang/rust/pull/36995 ने मूल ? सिंटैक्स को स्थिर किया, जो 1.14 में स्थिर होना चाहिए।

जोड़ने के लिए मत भूलना? अब इसके स्थिर होने के संदर्भ में ऑपरेटर: https://doc.rust-lang.org/nightly/reference.html#unary -Terator- अभिव्यक्तियाँ

और @bluss ने बताया कि पुस्तक पुरानी भी है: https://doc.rust-lang.org/nightly/book/syntax-index.html

@tomaka

मैं विस्तार करने का विरोध कर रहा हूं? विकल्प के लिए।

त्रुटि उद्देश्यों के लिए इसका उपयोग करने की आवश्यकता नहीं है। उदाहरण के लिए, यदि मैं get लेने के लिए एक आवरण विधि अपनाता हूं और किसी फ़ंक्शन द्वारा मैपिंग करता हूं, तो मैं None केस का प्रचार करने में सक्षम होना चाहूंगा।

? सिर्फ त्रुटियों के लिए किया जा रहा था; इस तरह के सामान्य प्रचार के लिए अधिक सामान्य संकेतन एक गैर-लक्ष्य था।

29 अक्टूबर 2016 को, 11:08 -0400, ticki सूचनाएं @github.com, ने लिखा:

@tomaka (https://github.com/tomaka)

मैं विस्तार करने का विरोध कर रहा हूं? विकल्प के लिए।

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

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub (https://github.com/rust-lang/rust/issues/31436#issuecomment-257096575) पर देखें, या थ्रेड को म्यूट करें (https://github.com/nactions/unsubscribe -auth / AABsipGIpTF1-7enk-z_5JRYYtl46FLPks5q42DCgaJpZM4HUm_-)।

यह (= ? स्वयं) अब एक स्थिर विशेषता है! (जंग से 1.13)

दो प्रलेखन मुद्दे:

• [x] पुस्तक # ३ the५० में अद्यतन त्रुटि हैंडलिंग अध्याय
• [x] वर्तमान स्थिति # ३। .५१ के लिए Carrier ट्रेट डॉक्स अपडेट करें

ध्यान दें कि न तो catch और न ही Carrier विशेषता को अभी तक ठीक से लागू किया गया है, बस ? सुविधा है।

Carrier मौजूद है, और ? का उपयोग करते समय त्रुटि संदेश इसे संदर्भित करते हैं, इसलिए यह बेहतर होगा कि कैरियर का मुद्दा अस्वीकार करने के बजाय तय किया गया हो। डॉक्स को भी अद्यतन करने की आवश्यकता है, क्योंकि डॉक्स इसे विकल्प के लिए कार्यान्वित किया जा रहा है। (जो झूठा है)।

35946 को त्रुटि संदेशों से Carrier का कोई उल्लेख हटा देना चाहिए। यह ध्वनि करता है जैसे हमें Carrier डॉक्स से Option उल्लेख को हटा देना चाहिए।

मैं Carrier विशेषता के साथ सहभागिता के कारण इस मुद्दे पर T-libs जोड़ रहा हूं

प्रश्न जो @cramertj का सामना करना पड़ा: https://internals.rust-lang.org/t/grammatical-ambiguity-raction-catch-blocks/4807

नमस्ते; # 31954 में त्रुटि प्रकार के लिए upcast From (और वर्तमान हेड में समान) का उपयोग करके किया जाता है, लेकिन RFC 243 में स्पष्ट रूप से Into का उपयोग रूपांतरण के लिए किया जाना चाहिए।

क्या इसके बजाय From का उपयोग करने का कोई कारण है? जब कुछ सामान्य त्रुटि प्रकार (अर्थात io::Error , या किसी अन्य चीज़ को किसी बाहरी टोकरा में) को बढ़ाने की कोशिश की जा रही है, तो स्थानीय त्रुटि प्रकारों के लिए From लागू नहीं किए जा सकते।

(RFC 243 के लेखक के रूप में FWIW मैंने इस बारे में बहुत मुश्किल नहीं सोचा कि क्या From या Into बेहतर है या नहीं, या नहीं या सही विकल्प नहीं बनाया है। जो कि सिर्फ इतना ही कहना है। प्रश्न को योग्यता के आधार पर तय किया जाना चाहिए (जो इस बिंदु पर पीछे की संगतता शामिल कर सकता है), बजाय इसके कि RFC में क्या लिखा गया है।)

अफसोस की बात है कि एक प्रतिगमन होगा। कोई (गैर तुच्छ) यदि From<...> एक त्रुटि प्रकार के लिए उदाहरण कार्यान्वित किया जाता है, संकलक कुछ मामलों में प्रकार यह मान सकते हैं, जहां यह यह का उपयोग करते समय निकालना नहीं कर सकते हैं Into (के सेट From उदाहरणों को वर्तमान टोकरा द्वारा सीमित किया जाता है, Into उदाहरणों का पूरा सेट एक टोकरा संकलन करते समय ज्ञात नहीं है)।

Https://play.rust-lang.org/?gist=6d3ee9f93c8b40094a80d3481b12dd00 ("सरलीकृत" एक वास्तविक दुनिया की समस्या जिसमें fmt::Error src / librustc / उपयोग / ppaux.rs # L81 शामिल है )

एक नया RFC है जो ? का वर्णन करने के मामले में पुराने को पीछे छोड़ देगा: जंग-लंग / rfcs / पुल / 1859

मैं -1 catch ब्लॉक्स बिल्कुल भी ले रहा हूं, जब वे क्लोजर के साथ पहले से अधिक संक्षिप्त हैं।

क्लोजर प्रवाह नियंत्रण बयानों के लिए हस्तक्षेप करते हैं। ( break , continue , return )

अब जबकि https://github.com/rust-lang/rfcs/pull/1859 का विलय कर दिया गया है, और दावा है कि हम इस मुद्दे को इसके ट्रैकिंग मुद्दे के रूप में फिर से उपयोग कर रहे हैं, मैं प्रस्ताव करना चाहूंगा कि हम catch पुनर्मूल्यांकन करें। RFC 243 का

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

मैं अभी भी पकड़ने के लिए उत्सुक हूं; पहले आज मुझे कुछ कोड को इस तरह से कंट्रोवर्सी में डालना पड़ा था कि अगर पकड़ स्थिर होती तो उसे टाला जा सकता था।

इस सुविधा को रात में सिंटैक्स do catch साथ लागू किया गया है, है ना?

@withoutboats हाँ, यह वर्तमान में do catch , क्योंकि catch { ... } struct catch { }; catch { } ।
।
@archshift @SimonSapin ने ऊपर बताया, break , continue , और return साथ हस्तक्षेप करते हैं।

@bstrie मुझे लगता है कि मैं बहुत बार इन दिनों catch चाहता हूं; रिफैक्टरिंग के दौरान यह बहुत ऊपर आता है।

मुझे महसूस नहीं हुआ कि हम सिंटैक्स के रूप में do catch आवश्यकता पर योजना बना रहे थे। यह देखते हुए कि वास्तविक-दुनिया के टूटने का जोखिम बहुत कम है (दोनों ने संरचना के नामकरण के दिशानिर्देशों का उल्लंघन किया है और निर्माता को बयान में पहली अभिव्यक्ति होगी (जो कि वापसी की स्थिति के बाहर दुर्लभ है)), क्या हम शायद सरसराहट का लाभ उठा सकते हैं catch_ लिए किसी भी आक्रामक पहचानकर्ताओं को फिर से लिखना? अगर यह करने के लिए रूस्ट 2.0 की आवश्यकता होती है, तो, ठीक है, मैं हमेशा से कहता रहा हूं कि जंग 2.0 को केवल तुच्छ परिवर्तन को शामिल करना चाहिए ... पी:

@bstrie हम बिल्कुल do catch लॉन्ग टर्म की आवश्यकता नहीं चाहते हैं। चर्चा है कि उस वाक्यविन्यास का उपयोग करने के लिए अब यहाँ है: https://github.com/rust-lang/rust/pull/39921

बहुत बढ़िया, संदर्भ के लिए धन्यवाद।

मैं सिर्फ यहाँ आया था क्योंकि मुझे आशा थी कि catch स्थिर था, और सीखना था कि यह नहीं है - इसलिए हाँ, बिल्कुल, अब ? स्थिर है, यह भी catch लिए बहुत अच्छा होगा

मैं यह देखना चाहता था कि हम इसके बाकी हिस्सों पर कितनी दूर तक जाएँगे और क्या हमने कैच की चर्चा को देखा।

मैं शायद एक मूर्खतापूर्ण विचार पर विचार कर रहा हूं जो इस तरह के मामलों में मदद करेगा: वैकल्पिक रूप से @ या कुछ अन्य sigil के साथ कीवर्ड को उपसर्ग करने की अनुमति दें, फिर सभी नए कीवर्ड केवल sigil का उपयोग करें। हमें कोरटाउन चर्चा के साथ भी ऐसी ही समस्या थी। मैं याद नहीं कर सकता कि क्या मैं वहाँ एक समाधान के रूप में गया था - मेरे पास हो सकता है - लेकिन ऐसा लग रहा है कि यह जारी रह सकता है।

FWIW, C # वास्तव में विपरीत का समर्थन करता है: पहचानकर्ताओं के रूप में कीवर्ड का उपयोग करने के लिए @ । यह आमतौर पर रेजर में देखा जाता है, जहां आप HTML नोड पर प्रॉपर्टी सेट करने के लिए new { <strong i="6">@class</strong> = "errorbox" } जैसी चीजें पास करते हैं।

@scottmcm
यह तो दिलचस्प है। मैं इसके बारे में नहीं जानता था। लेकिन जंग के लिए हमें दूसरे रास्ते पर जाना होगा क्योंकि अनुकूलता।

हालांकि उनके हिस्से पर नीट का विचार है। .Net इकोसिस्टम में बहुत सी भाषाएं हैं, सभी अलग-अलग कीवर्ड हैं और सभी एक दूसरे को कॉल करने में सक्षम हैं।

कीवर्ड के भविष्य के लिए एक अन्य संभावना: उन्हें एक विशेषता के पीछे रखें, जैसे कि स्थिर #[feature] ।

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

@camlorn यह सूत्र आपको रूचि दे सकता है, विशेष रूप से हारून के विचार "एपोच" के बारे में हारून का विचार: https://internals.rust-lang.org/t/pre-rfc-stable-features-for-breaking/changes/5002

मुझे लगता है कि हमें यहाँ समस्या विवरण से https://github.com/rust-lang/rust/issues/42327 लिंक करना चाहिए। (यहां भी शायद RFC टेक्स्ट को यहां के बजाय लिंक करने के लिए अपडेट किया जाना चाहिए।)

(संपादित करें: मैंने वहां एक टिप्पणी पोस्ट की है, यह सुनिश्चित नहीं है कि कौन पहले से ही इसकी सदस्यता ले चुका है या नहीं!)

@camlorn , हालांकि, यह "जंग से मुक्त करने के लिए थोड़ी देर के लिए एक तुच्छ फिर से लिखना करता है, खोल सकता है, तो यह एक कीवर्ड" पथ बन जाता है। एकेए का फायदा उठाते हैं "यह नहीं टूट रहा है अगर कोई अतिरिक्त एनोटेशन है जो लिखा जा सकता था कि यह स्थिरता की गारंटी में दोनों से बच जाएगा" हैच। और, अनुमान परिवर्तन के लिए UFCS के समान, एक काल्पनिक "पूरी तरह से विस्तृत रूप में स्टोर" मॉडल पुराने गेट्स को काम कर सकता है।

मुझे कोई आपत्ति नहीं होगी यदि कैच ब्लॉक के लिए सिंटैक्स सिर्फ do { … } या ?{ … }

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

यह भी दिखता है, लेकिन प्रस्तावित अभिव्यक्ति के javascripts से अलग व्यवहार करता है

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

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

इसमें हास्केल जैसी डू-नोटेशन को लागू करने की संदिग्ध (आपके दृष्टिकोण के आधार पर) संपत्ति है

@rpjohnst रिजल्ट और ऑप्शन

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

उसी समय, जबकि हम शायद इसे पूर्ण-संकेतन के साथ आगे-संगत कर सकते थे, हमें संभवतः पूर्ण-संकेतन नहीं जोड़ना if / while / for / loop या break / continue जैसी नियंत्रण संरचनाओं के साथ स्वीकार्य नहीं है। return , जो हमें catch (या इस मामले में do ) के ब्लॉक के अंदर और उसके भीतर उपयोग करने में सक्षम होना चाहिए। (ऐसा इसलिए है क्योंकि उच्च क्रम कार्यों के संदर्भ में पूर्ण डू-नोटेशन को परिभाषित किया गया है, और अगर हम नेस्टेड क्लोजर की श्रृंखला में catch ब्लॉक की सामग्री को भरते हैं, तो अचानक सभी प्रवाह को नियंत्रित करते हैं।)

तो अंत में के इस नकारात्मक पक्ष यह do कि यह वास्तव में किया जा रहा do-अंकन के बिना do-अंकन की तरह लग रहा है, और एक अच्छा do-अंकन या तो बनने के लिए आगे पथ के बिना है। व्यक्तिगत रूप से, मैं इसके साथ पूरी तरह से ठीक हूं क्योंकि रस्ट को do नोटेशन वैसे भी नहीं मिलने वाला है - लेकिन यह भ्रम है।

@nikomatsakis , # 42526 को मर्ज किया गया है, आप इसे ट्रैकिंग सूची में किए गए अनुसार चिह्नित कर सकते हैं :)

क्या catch कीवर्ड को प्रासंगिक बनाना संभव है, लेकिन यदि struct catch कार्यक्षेत्र में है, तो उसे अक्षम कर दें और एक अवमूल्यन की चेतावनी जारी करें?

यह निश्चित नहीं है कि यह कितना उपयुक्त है, लेकिन मैं एक ऐसे मुद्दे पर भाग गया, जिसमें शायद इसे हल करने की आवश्यकता है जिसमें कभी-कभी आप त्रुटि मूल्य के बजाय एक ठीक करना चाहते हैं जो वर्तमान में संभव है जब आप return insofar का उपयोग करते हैं जो आप अक्सर चाहते हैं एक रूटर के माध्यम से _inner_ त्रुटि को ठीक करें। जैसे जब कोई फंक्शन कहता है कि Option<Result<_,_>> जो कि itter कहने से काफी आम है।

विशेष रूप से मेरे पास एक परियोजना में एक मैक्रो है, जिसका मैं अभी उपयोग करता हूं:

macro-rules! option_try {
    ( $expr:expr ) => {
        match $expr {
            Ok(x)  => x,
            Err(e) => return Some(Err(e.into())),
        }
    }
}

यह बहुत ही सामान्य बात है कि Iterator::next कार्यान्वयन के भीतर एक फ़ंक्शन को विफलता पर Some(Err(e)) साथ तुरंत समाप्त करने की आवश्यकता है। यह मैक्रो एक सामान्य फंक्शन बॉडी के अंदर काम करता है लेकिन कैच ब्लॉक के अंदर नहीं क्योंकि कैच return नहीं हड़पता है बल्कि सिर्फ ? सिंटैक्स होता है।

हालांकि अंत में लेबल-रिटर्न पूरे catch ब्लॉक विचार को बेमानी बना देगा?

ऐसा लग रहा है कि # 41414 हो गया है। क्या कोई ओपी को अपडेट कर सकता है?

अद्यतन: RFC जंग-लंग / rfcs # 2388 अब विलय कर दिया गया है और इसलिए catch { .. } को try { .. } साथ प्रतिस्थापित किया जाना है।
इस टिप्पणी के ठीक ऊपर ट्रैकिंग समस्या देखें।

संस्करण 2015 के लिए इसका क्या मतलब है, स्थिरीकरण की दिशा में अभी भी do catch { .. } सिंटैक्स है या इसे गिरा दिया जाएगा और केवल संस्करण 2018+ में try { .. } माध्यम से समर्थित होगा?

@ निम्मो 157 उत्तरार्द्ध।

क्या वर्तमान प्रस्ताव में दो-कथन try ... catch ... है? यदि हां, तो मुझे शब्दार्थ नहीं मिलता।

वैसे भी, अगर यह प्रस्ताव केवल उबाऊ है तो मैं इसके साथ अच्छा हूं। यानी क्या catch ब्लॉक केवल ? ऑपरेटर से बाहर निकलता है?

जैसा कि सभी चेक बॉक्स शीर्ष पद पर टिक गए हैं, हम कब आगे बढ़ेंगे? यदि अभी भी अनसुलझे मुद्दे हैं तो हमें नए चेक बॉक्स (तों) जोड़े जाने की आवश्यकता है।

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

हम्म ... यह मुझे परेशान करता है कि इन सवालों को दर्ज नहीं किया गया है।

@ mark-im तो स्पष्ट करने के लिए, मुझे लगता है कि वे कहीं रहे हैं; लेकिन एक स्थान पर नहीं; यह विभिन्न RFC और मुद्दों में थोड़ा बिखरा हुआ atm है और इसलिए, हमें जो करने की आवश्यकता है, उन्हें उचित स्थानों पर रिकॉर्ड किया गया है।

बैकिंग विशेषता का डिज़ाइन https://github.com/rust-lang/rust/issues/42327 में ट्रैक किया गया है

इसलिए मुझे लगता है कि केवल try{} यहां बचा है, और इसके लिए केवल असहमति मुझे पता है कि वे चीजें हैं जो RFC में तय की गईं और उपर्युक्त मुद्दों में से एक में फिर से पुष्टि की गई। यह अभी भी एक अलग ट्रैकिंग मुद्दा है अच्छा हो सकता है, हालांकि।

मैं एक लंबित कार्यान्वयन कार्य के लिए एक चेकबॉक्स जोड़ूंगा जो मुझे पता है कि अभी भी करने की आवश्यकता है ...

@scottmcm मैं जानता हूँ कि @joshtriplett (में नोट ठीक-रैपिंग के बारे में चिंताओं था try RFC) और मैं प्रतिबंधित करने के लिए व्यक्तिगत रूप से की तरह था break के प्रारंभिक स्थिरीकरण में try { .. } तो कि आप loop { try { break } } और ऐसा नहीं कर सकते।

@Centril

ताकि आप loop { try { break } } न कर सकें

अभी, आप नॉन-लूप ब्लॉक में break का उपयोग नहीं कर सकते हैं, और यह सही है: break उपयोग केवल लूप में किया जाना चाहिए। एक try ब्लॉक को जल्दी छोड़ने के लिए, मानक तरीका Err(e)? लिखना है। और यह बल देता है कि शुरुआती पत्ते हमेशा "असामान्य" नियंत्रण पथ में होते हैं।

तो मेरा प्रस्ताव है कि आपके द्वारा दिखाए गए कोड को अनुमति दी जानी चाहिए, और यह loop को तोड़ना चाहिए, न कि केवल try छोड़कर।

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

@ संतरी उन लोगों को उठाने के लिए धन्यवाद।

break , मैं व्यक्तिगत रूप से बस यह कहकर ठीक हो जाऊंगा कि try break परवाह नहीं करता है और यह युक्त लूप से गुजरता है। मैं break try साथ बातचीत करने के लिए बिल्कुल नहीं चाहता हूं।

Ok -wrapping के लिए, हाँ, मैं try स्थिर करने से पहले संबोधित करना चाहूंगा।

@centril हाँ, मुझे पता है। लेकिन यह है कि फिर से फिर से इस मुद्दे को उठा रहा है याद रखना महत्वपूर्ण है। RFC ने इसे करने का फैसला किया , इसे इसके बिना लागू किया गया था, लेकिन तब मूल इरादा _again_ लिया गया था , और कार्यान्वयन RFC का पालन करने के लिए बदल गया। इसलिए मेरा बड़ा सवाल यह है कि क्या कोई भौतिक तथ्य बदल गया है, विशेष रूप से यह देखते हुए कि यह उन सबसे नीच विषयों में से एक है जिसे मैंने कभी RFC + IRLO पर चर्चा करते देखा है।

@scottmcm बेशक, जैसा कि आप जानते हैं, मैं Ok -wrapping बनाए रखने से सहमत हूं;) और मैं सहमत हूं कि इस मुद्दे पर विचार किया जाना चाहिए।

मैं सिर्फ इस पर टिप्पणी करना चाहता था, निश्चित नहीं कि यह सही बात है:

अनिवार्य रूप से, एक स्थिति जो मेरे पास जीयूआई ढांचे में कॉलबैक है - एक Option या Result वापस करने के बजाय, उन्हें फ्रेम को बताने के लिए UpdateScreen वापस करने की आवश्यकता है, अगर स्क्रीन अद्यतन किया जाना चाहिए या नहीं। अक्सर मुझे बिल्कुल भी लॉग इन करने की आवश्यकता नहीं होती है (यह हर छोटी सी त्रुटि पर लॉग इन करना व्यावहारिक नहीं है) और बस एक त्रुटि होने पर UpdateScreen::DontRedraw करते हैं। हालांकि, वर्तमान ? ऑपरेटर के साथ, मुझे हर समय यह लिखना होगा:

let thing = match fs::read(path) {
    Ok(o) => o,
    Err(_) => return UpdateScreen::DontRedraw,
};

चूँकि मैं ट्राई ऑपरेटर के माध्यम से Result::Err को UpdateScreen::DontRedraw परिवर्तित नहीं कर सकता हूँ, इससे बहुत थकाऊ हो जाता है - अक्सर मेरे पास हैश मैप्स में साधारण लुकअप होते हैं जो विफल हो सकते हैं (जो एक त्रुटि नहीं है ) - तो अक्सर एक कॉलबैक में मेरे पास ? ऑपरेटर के 5 - 10 उपयोग होते हैं। क्योंकि ऊपर लिखने के लिए बहुत क्रिया है, मेरा वर्तमान समाधान impl From<Result<T>> for UpdateScreen इस तरह से है , और फिर कॉलबैक में एक आंतरिक फ़ंक्शन का उपयोग इस तरह से करें:

fn callback(data: &mut State) -> UpdateScreen {
     fn callback_inner(data: &mut State) -> Option<()> {
         let file_contents = fs::read_to_string(data.path).ok()?;
         data.loaded_file = Some(file_contents);
         Some(())
     }

    callback_inner(data).into()
}

चूंकि कॉलबैक का उपयोग फ़ंक्शन पॉइंटर के रूप में किया जाता है, इसलिए मैं -> impl Into<UpdateScreen> उपयोग नहीं कर सकता (किसी कारण से, impl वर्तमान में फ़ंक्शन पॉइंटर्स के लिए अनुमति नहीं है)। तो मेरे लिए Try ऑपरेटर का उपयोग करने का एकमात्र तरीका आंतरिक-फ़ंक्शन चाल है। यह अच्छा होगा अगर मैं बस इस तरह से कुछ कर सकता हूं:

impl<T> Try<Result<T>> for UpdateScreen {
    fn try(original: Result<T>) -> Try<T, UpdateScreen> {
        match original {
             Ok(o) => Try::DontReturn(o),
             Err(_) => Try::Return(UpdateScreen::DontRedraw),
        }
    }
}

fn callback(data: &mut State) -> UpdateScreen {
     // On any Result::Err, convert to an UpdateScreeen::DontRedraw and return
     let file_contents = fs::read_to_string(data.path)?;
     data.loaded_file = Some(file_contents);
     UpdateScreen::Redraw
}

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

संपादित करें:
मैंने भूल की।

इस पोस्ट को अनदेखा करें

यह प्रकार के अनुमान के साथ बेहतर खेल सकता है, यह सरल मामलों में भी विफल रहता है।

fn test_try(a: u32, b: u32) {
    let div = if b != 0 {
        Some(a / b)
    } else {
        None
    };

    let x // : Option<_> // why is this type annotation necessary
    = try { div? + 1 };

    println!("{:?}", x);
}

यदि इसे फिर से ब्लॉक के बजाय एक बंद का उपयोग करने के लिए लिखा गया है (और इस प्रक्रिया में ऑटो रैपिंग ढीली है), तो हम प्राप्त करते हैं

fn test_closure(a: u32, b: u32) {
    let div = if b != 0 {
        Some(a / b)
    } else {
        None
    };

    let x =  (|| (div? + 1).into())();

    println!("{:?}", x);
}

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

खेल का मैदान

@KrishnaSannasi आपके क्लोजर आधारित उदाहरण में एक प्रकार की खेल का मैदान ) है, क्योंकि Into आउटपुट को बाधित नहीं करता है और आप इसे कहीं भी उपयोग नहीं करते हैं जो बाद में करता है।

ऐसा लगता है कि ज्यादातर Try try ब्लॉक के बजाय Into आउटपुट प्रकार को इसके बाद के उपयोग द्वारा निर्धारित किया जाना चाहिए। लक्षण के बारे में https://github.com/rust-lang/rust/issues/42327 में चर्चा का एक _lot_ है, मैंने इसे नहीं पढ़ा है इसलिए मुझे यकीन नहीं है कि अगर कोई प्रस्ताव इस मुद्दे को ठीक कर सकता है।

@ Nemo157

हां, मैंने अपने कोड में अंतिम मिनट परिवर्तन किया था, इसे उपयोग करने के लिए, और उस का परीक्षण नहीं किया। मेरी गलती।

हम कितनी बार कोशिश ब्लॉकों को स्थिर करने से हैं? यह एकमात्र विशेषता है जिसकी मुझे रात्रि से आवश्यकता है: D

@Arignir

मेरा मानना ​​है कि एक बार ऐसा करने के बाद, इसे स्थिर किया जा सकता है।

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

क्या अब भी इस सुविधा की अनुमति देने के लिए कोई मध्यम जमीन डिजाइन नहीं है, जबकि अभी भी भविष्य के लिए डिजाइन की जगह को खुला छोड़ने की संभावना है (और इसलिए catch ब्लॉक)?

मैंने जो PR बनाया है, उस बॉक्स को वैसे भी चेक करना चाहिए, CC @nikomatsakis

मैंने कल पहली बार इसका उपयोग करने की कोशिश की, और मुझे थोड़ा आश्चर्य हुआ कि यह:

#![feature(try_blocks)]
fn main() -> Result<(), ()> {
    let x: () = try {
        Err(())?
    }?;
    Ok(x)
}

के कारण संकलन नहीं करता है

error[E0284]: type annotations required: cannot resolve `<_ as std::ops::Try>::Ok == _`

बल्कि, मुझे करना था

#![feature(try_blocks)]
fn main() -> Result<(), ()> {
    let x: Result<(), ()> = try {
        Err(())?
    };
    let x = x?;
    Ok(x)
}

बजाय।

यह पहली बार भ्रामक था, इसलिए शायद यह त्रुटि संदेश को बदलने या --explain में उल्लेख के लायक है?

यदि आप अपने पहले उदाहरण में प्रश्न चिह्न को थोड़ा नीचे ले जाते हैं

#![feature(try_blocks)]
fn main() -> Result<(), ()> {
    let x: () = try {
        Err(())?
    };
    Ok(x?)
}

आपको एक बेहतर त्रुटि संदेश मिलता है। यह त्रुटि सामने आई क्योंकि रुस्ट यह तय नहीं कर सकता है कि यह किस प्रकार सामान्य है, इसके कारण try { ... } को हल करना है। क्योंकि यह इस प्रकार को हल नहीं कर सकता है, यह नहीं जान सकता है कि <_ as Try>::Ok प्रकार क्या है, यही कारण है कि आपको वह त्रुटि मिली जो आपने की थी। (क्योंकि ? ऑपरेटर unwraps Try प्रकार और वापस देता है Try::Ok प्रकार)। जंग Try::Ok साथ काम नहीं कर सकती है, यह अपने आप में Try विशेषता के माध्यम से हल किया जाना चाहिए, और प्रकार जो उस गुण को लागू करता है। (जो मौजूदा तरीके की जाँच कार्यों की एक सीमा है)

इस सुविधा के लिए सब कुछ लागू है, सही है? यदि हां, तो हम स्थिर होने से पहले इस पर बैठे हुए कब तक देखना चाहते हैं?

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

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

विशेष रूप से, इस बारे में कुछ चर्चा हुई कि क्या हम यहां अपवादों की भाषा का उपयोग करना चाहते हैं (प्रयास करें, पकड़ें)।

मुझे लगता है कि https://github.com/rust-lang/rfcs/pull/2388 निश्चित रूप से बस गया कि क्या try एक नाम के रूप में स्वीकार्य है। यह एक खुला प्रश्न नहीं है। लेकिन Try विशेषता के साथ-साथ Ok -wrapping की परिभाषा प्रतीत होती है।

मूल आरएफसी में Ok -wrapping पहले से ही तय किया गया था, फिर कार्यान्वयन के दौरान हटा दिया गया, और बाद में फिर से जोड़ा गया। मैं नहीं देखता कि यह एक खुला सवाल कैसे है।

@rpjohnst वैसे यह जोश के आधार पर है जो मूल RFC के फैसले से असहमत हैं ... :) यह मेरे लिए एक सुलझा हुआ मामला Https://github.com/rust-lang/rust/issues/31436#issuecomment -427096703, https://github.com/rust-lang/rust/issues/31436#issuecomment -427252202, और https: // देखें github.com/rust-lang/rust/issues/31436#issuecomment -437129491। वैसे भी ... मेरी टिप्पणी का मुद्दा यह था कि try "अपवादों की भाषा" के रूप में एक सुलझा हुआ मामला है।

वाह, यह कब हुआ? आखिरी चीज जो मुझे याद है, वह थी इंटर्नल पर चर्चा। ठीक है, रैपिंग के खिलाफ बहुत ज्यादा :(

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

RFC 243 में स्वीकृत Ok -wrapping (शाब्दिक रूप से जिसने ? ऑपरेटर को परिभाषित किया है, अगर आप सोच रहे थे कि ऐसा कब हुआ था) फ़ंक्शन रिटर्न अभिव्यक्तियों के प्रकारों के बारे में कुछ भी नहीं बदलता है। इस तरह से RFC 243 ने इसे परिभाषित किया: https://github.com/rust-lang/rfcs/blob/master/text/0243-trait-based-exception-handling.md#catch -expressions

यह RFC catch {..} एक अभिव्यक्ति फ़ॉर्म भी प्रस्तुत करता है, जो ? ऑपरेटर को "स्कोप" करने का कार्य करता है। catch ऑपरेटर अपने संबंधित ब्लॉक को निष्पादित करता है। यदि कोई अपवाद नहीं फेंका गया है, तो परिणाम Ok(v) जहां v ब्लॉक का मूल्य है। अन्यथा, यदि एक अपवाद को फेंक दिया जाता है, तो परिणाम Err(e) ।

ध्यान दें कि catch { foo()? } अनिवार्य रूप से foo() बराबर है।

यही है, यह T प्रकार का एक ब्लॉक लेता है और बिना शर्त के इसे Result<T, _> मूल्य का उत्पादन करने के लिए लपेटता है। ब्लॉक में कोई भी return बयान पूरी तरह से अप्रभावित है; यदि ब्लॉक एक फ़ंक्शन की पूंछ अभिव्यक्ति है, तो फ़ंक्शन को Result<T, _> वापस करना होगा।

यह इस तरह से रात के लिए उम्र के लिए लागू किया गया है: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=88379a1607d952d4ea4d1d06394b50959। यह लंग टीम द्वारा बहुत चर्चा के बाद किया गया था, और इस धागे से जुड़ा था: जंग-लंग / जंग # 41414 (और यह इस मुद्दे के शीर्ष पर भी जुड़ा हुआ है)।

28 मई, 2019 5:48:27 अपराह्न पीडीटी, अलेक्जेंडर रेगुएरो नोटिफिकेशन @github.com ने लिखा:

Eww। यकीन नहीं हुआ कि ऐसा हुआ। Ok -लिंग बहुत भयानक है (यह)
बहुत समझदार अंतर्ज्ञान को तोड़ता है कि सभी एक में अभिव्यक्ति लौटाते हैं
फ़ंक्शन फ़ंक्शन के रिटर्न प्रकार का होना चाहिए)। तो हाँ, निश्चित रूप से
इस पर @ चिह्न-इम के साथ। क्या जोश की असहमति इस बात को रखने के लिए पर्याप्त है
खुला मुद्दा, और इस पर अधिक चर्चा करें? मैं ख़ुशी से उसे समर्थन देना चाहता हूँ
इससे लड़ने में, यह नहीं कि इसका मतलब गैर-टीम के सदस्य के रूप में कुछ है।

धन्यवाद। मैं केवल इस बात से असहमत नहीं हूँ मैं उन कई लोगों का भी प्रतिनिधित्व कर रहा हूं जिन्हें मैंने वही स्थिति व्यक्त करते हुए देखा है जो मैं करता हूं।

@joshtriplett @ mark-im @alexreg

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

Tue पर, 28 मई, 2019 को 03:40:47 PM -0700 पर, रसेल जॉनसन ने लिखा:

मूल आरएफसी में Ok -wrapping पहले से ही तय किया गया था, फिर कार्यान्वयन के दौरान हटा दिया गया, और बाद में फिर से जोड़ा गया। मैं नहीं देखता कि यह एक खुला सवाल कैसे है।

मुझे लगता है कि आपने आंशिक रूप से अपने प्रश्न का उत्तर दिया। मुझे नहीं लगता कि हर कोई
मूल RFC चर्चा में उसी पृष्ठ पर शामिल था; try था
बिल्कुल कुछ लोग चाहते थे, लेकिन आम सहमति नहीं थी
ओके-रैपिंग के लिए।

Tue पर, 28 मई, 2019 को 03:44:46 अपराह्न -0700, Mazdak Farrokhzad ने लिखा:

वैसे भी ... मेरी टिप्पणी का मुद्दा यह था कि try "अपवादों की भाषा" के रूप में एक सुलझा हुआ मामला है।

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

28 मई, 2019 को 11:37:33 PM -0700 पर ट्यु, गेब्रियल स्मिथ ने लिखा:

क्या आप में से कोई यह समझा सकता है कि आप इतने असहमत होने के लिए Ok रैपिंग क्यों पाते हैं

कुछ कारणों में से एक के रूप में:

Tue पर, 28 मई, 2019 को 05:48:27 PM -0700 पर, अलेक्जेंडर रेगुइरो ने लिखा:

यह बहुत समझदार अंतर्ज्ञान को तोड़ता है कि एक फ़ंक्शन में सभी वापसी अभिव्यक्तियाँ फ़ंक्शन के रिटर्न प्रकार की होनी चाहिए

यह उन लोगों के लिए विभिन्न दृष्टिकोणों को तोड़ता है जो टाइप-निर्देशित तर्क के लिए उपयोग करते हैं
कार्यों और कोड संरचना के बारे में।

मेरे पास निश्चित रूप से मेरे अपने विचार हैं, लेकिन क्या हम अभी इस विषय को फिर से नहीं खोल सकते हैं? सिंटैक्स के बारे में हमारे पास सिर्फ एक विवादास्पद 500+ पोस्ट की बातचीत थी, इसलिए मैं कुछ समय के लिए बारूदी सुरंगों से बचना चाहूंगा।

यदि यह चर्चा करने वाली लैंग टीम पर अवरुद्ध है, तो "रिज़ॉल्यूशन कैच ब्लॉक्स" रैप वैल्यू (# 41414) "चेकबॉक्स को फिर से अनचेक किया जाना चाहिए (शायद एक टिप्पणी के साथ कि यह लैंग टीम पर अवरुद्ध है) ताकि लोग देख रहे हों इस ट्रैकिंग मुद्दे की स्थिति पता है?

क्षमायाचना, मैं कुछ भी फिर से खोलने की कोशिश नहीं कर रहा हूं- बस यह ट्रैक करने के मामले में तय किए गए के रूप में चिह्नित किया गया है और जब + कैसे हुआ।

@rpjohnst जानकारी के लिए धन्यवाद!

@yodaldevoid जोश ने मेरे विचारों को बहुत संक्षेप में प्रस्तुत किया।

मैं एक ब्लॉक तक सीमित ओप्प-रैपिंग के विपरीत थोड़ा कम हूं (जैसा कि किसी फ़ंक्शन के प्रकार को प्रभावित करने के लिए), लेकिन मुझे लगता है कि यह अभी भी एक बुरी मिसाल कायम करता है: जैसा कि जोश ने कहा था "मुझे अपवादों के रूपक आकर्षक नहीं लगते"

@joshtriplett ने अनिवार्य रूप से मेरे विचारों को भी संक्षेप में प्रस्तुत किया है: मुद्दे "अपवाद" रूपक (यकीनन आतंक + catch_unwind बहुत अधिक विनम्र) और टाइप-आधारित तर्क की उपयुक्तता हैं। मैं स्कोपिंग और नियंत्रण-प्रवाह तंत्र के रूप में try ब्लॉक के साथ वास्तव में ठीक हूं, लेकिन अधिक कट्टरपंथी बिंदु नहीं।

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

क्या प्रकार के एनोटेशन के लिए एक वाक्यविन्यास पर सहमति हुई है? मैं कुछ try { foo()?; bar()?; }.with_context(|_| failure::err_msg("foon' n' barn'")?; उम्मीद कर रहा था, जो कि दूर से भी संकलन में रुचि नहीं रखता है: error[E0282]: type annotations needed ।

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=4e60d44a8f960cf03307a809e1a3b5f2

मैं टिप्पणियों के माध्यम से थोड़ी देर पहले पढ़ा (और लोड हो रहा है 300 टिप्पणियों फिर GitHub पर भी कठिन रास्ता है), लेकिन मुझे याद है कि सबसे (यदि सभी नहीं) के आसपास बहस के बारे में उदाहरण के Try::Ok प्रयुक्त लपेटकर Ok उदाहरण में Option Try रूप में अच्छी तरह से विचार करते हुए, मैं यह जानना चाहूंगा कि टीम की स्थिति पर किस तरह का प्रभाव पड़ता है, जिस पर बहस होना है।

हर बार जब मैं रस्ट का उपयोग करता हूं, तो मैं सोचता रहता हूं "आदमी, मैं वास्तव में चाहता हूं कि मैं यहां एक कोशिश ब्लॉक का उपयोग कर सकता हूं," लेकिन लगभग 30% समय ऐसा है क्योंकि मैं वास्तव में चाहता हूं कि मैं Option s के लिए प्रयास कर सकता हूं (जैसे मैंने स्काला में उपयोग किया था, जो सामान्य रूप से मोनाड्स पर लागू करने के लिए for वाक्यविन्यास का उपयोग करता था, लेकिन यहां try है)।

बस आज, मैं json टोकरा का उपयोग कर रहा था और यह as_* तरीकों को उजागर करता है जो विकल्प लौटाते हैं।

दो वाक्यविन्यासों का उपयोग करते हुए, मेरा उदाहरण होगा:

match s {
  "^=" => |a, b| try { a.as_str()?.starts_with(b.as_str()?) }.unwrap_or(false),
  "$=" => |a, b| try { Some(a.as_str()?.ends_with(b.as_str()?)) }.unwrap_or(false),
  // original
  "$=" => |a, b| {
    a.as_str()
      .and_then(|a| b.as_str().map(|b| (a, b)))
      .map(|(a, b)| a.starts_with(b))
      .unwrap_or(false)
    },
}

मुझे लगता है कि, संदर्भ में, वापसी प्रकार Option या Result बहुत स्पष्ट है, और moreso, यह वास्तव में कोई फर्क नहीं पड़ता (जहां तक ​​कोड समझ जाता है)। पारदर्शी रूप से, अर्थ स्पष्ट है: "मुझे यह जांचने की आवश्यकता है कि क्या ये दो चीजें वैध हैं और उन पर एक ऑपरेशन करना है।" अगर मुझे इनमें से एक को चुनना था, तो मैं पहले के साथ जाऊंगा, क्योंकि मुझे विश्वास नहीं है कि जब आप समझते हैं कि इस फ़ंक्शन को एक बड़े संदर्भ में एम्बेड किया गया है, तो try रूप में कोई नुकसान नहीं होगा। हमेशा रहें।

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

मैंने मूल रूप से सोचा था कि Ok रैपिंग उस मामले में बेहतर होगी जहां आपका अंतिम कथन एक फ़ंक्शन है जो Try लागू करने वाले प्रकार को वापस करता है, लेकिन वाक्यविन्यास में अंतर होगा

try {
  fallible_fn()
}

try {
  fallible_fn()?
}

और इस मामले में, मुझे फिर से Ok -wrapping बेहतर लगता है क्योंकि यह स्पष्ट करता है कि fallible_fn Try वापसी का कार्य है, इसलिए यह वास्तव में अधिक स्पष्ट है।

मैं जानना चाहता हूं कि विपक्ष इस बारे में क्या सोचता है, और, क्योंकि मैं इस धागे में कई अन्य लोगों को नहीं देख सकता, @joshtriplett।

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

मैं कुछ नेस्टेड Option पार्सिंग के लिए try एक शॉट देना चाहता था:

#![feature(try_blocks)]

struct Config {
    log: Option<LogConfig>,
}

struct LogConfig {
    level: Option<String>,
}

fn example(config: &Config) {
    let x: &str = try { config.log?.level? }.unwrap_or("foo");
}

इसके साथ विफल रहता है

error[E0282]: type annotations needed
  --> src/lib.rs:12:19
   |
12 |     let x: &str = try { config.log?.level? }.unwrap_or("foo");
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
   |
   = note: type must be known at this point

मैं जो सबसे पास था

fn example(config: &Config) {
    let x: Option<&str> = try { &**config.log.as_ref()?.level.as_ref()? };
    let x = x.unwrap_or("foo");
}

as_ref काफी दुर्भाग्यपूर्ण है। मुझे पता है कि Option::deref कुछ यहाँ मदद करेंगे, लेकिन पर्याप्त नहीं। ऐसा लगता है कि किसी तरह मैच एर्गोनॉमिक्स (या संबंधित विचार) को खेल में आना चाहिए।

कई लाइनें भी दुर्भाग्यपूर्ण हैं।

क्या try पूर्णांक शाब्दिक की तरह Result का एक अंतर्ग्रहण दोष का उपयोग कर सकता है? कि @shepmaster का पहला प्रयास Result<&str, NoneError> ? शेष बचे मुद्दे क्या होंगे- शायद ? s के लिए एक सामान्य त्रुटि प्रकार खोजने के लिए? (क्या मैंने इसकी चर्चा कहीं मिस कर दी है?)

@shepmaster मैं प्रकार के अनुमान से सहमत हूं। मजेदार रूप से पर्याप्त, हालांकि, मैंने आपके सटीक कोड को कुछ भोले try_ क्रियान्वयन के साथ आज़माया और यह ठीक काम करता है: https://github.com/norcalli/koption_macros/blob/4362f88fa9b6c62fdaef4df30060438111141e7/src/lib#lib##

    let x = try_! { config.log?.level? }.unwrap_or("foo".to_owned());
    assert_eq!(x, "debug");

ठीक काम करता है।

कुछ हद तक try_ कार्यान्वयन

हां, लेकिन आपके मैक्रो इनवोकेशन पर String रिटर्न होता है, न कि &str , स्वामित्व की आवश्यकता होती है। आप आसपास का कोड नहीं दिखाते हैं, लेकिन यह विफल हो जाएगा क्योंकि हमारे पास Config का स्वामित्व नहीं है:

fn example(config: &Config) {
    let x = try_! { config.log?.level? }.unwrap_or_else(|| String::from("foo"));
}

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> src/lib.rs:20:21
   |
19 | fn example(config: &Config) {
   |            ------ captured outer variable
20 |     let x = try_! { config.log?.level? }.unwrap_or_else(|| String::from("foo"));
   |                     ^^^^^^^^^^ cannot move out of captured variable in an `Fn` closure

यह बिना शर्त के भी String आवंटित करता है; मैंने उस अक्षमता से बचने के लिए इस उदाहरण में unwrap_or_else किया।

यह शर्म की बात है कि यह सुविधा async/await ब्लॉक से पहले स्थिर नहीं की गई थी। IMO यह अधिक सुसंगत होता

let fut = async try {
    fut1().await?;
    fut2().await?;
    Ok(())
};

इसके बजाय यह try बिना काम करने की अनुमति देता है। लेकिन मुझे लगता है कि जहाज बहुत देर से रवाना हुआ है।

पुन: ऑटो-रैपिंग, मुझे नहीं लगता कि यह अब async ब्लॉक के अनुरूप होना संभव होगा। async ब्लॉक एक प्रकार के "ऑटो-रैपिंग" करते हैं, एक गुमनाम प्रकार में Future । लेकिन शुरुआती रिटर्न के साथ भी यह सही है, जो try ब्लॉक के साथ संभव नहीं होगा।

अगर हम कभी काल्पनिक async try ब्लॉक करते हैं तो यह दोगुना भ्रमित हो सकता है। उस ऑटो-रिजल्ट को लपेटना चाहिए?

मुझे नहीं लगता कि हमने ऑटो-रैपिंग अर्थों में स्थिरता पर कोई संभावना खो दी है। दोनों async ब्लॉक और फ़ंक्शंस ? उपयोग कर सकते हैं, और दोनों को अपने स्वयं के मैनुअल Ok -wrapping, दोनों शुरुआती और अंतिम रिटर्न के लिए करना चाहिए।

एक try ब्लॉक, दूसरे हाथ पर, इस्तेमाल कर सकते हैं ? स्वत: के साथ Ok , -wrapping "जल्दी रिटर्न" एक प्रारंभिक वापसी संभालने के लिए सहित सुविधा- शायद लेबल BREAK- मान । एक काल्पनिक कोशिश समारोह आसानी से दोनों प्रारंभिक और अंतिम रिटर्न पर स्वत: Ok -wrapping कर सकता है।

एक काल्पनिक async try ब्लॉक केवल दो ऑटो की कार्यक्षमता को जोड़ सकता है- Ok -wrap, और फिर ऑटो- Future -wrap। (अन्य तरीके से लागू करना असंभव है, और यकीनन try async लिखा जाएगा।)

जो असंगतता मुझे दिखाई देती है वह यह है कि हमने async कार्यों के साथ खंडों को जब्त कर लिया है। (यह RFC के अंतिम समय में हुआ, कोई कम नहीं है।) इसका क्या मतलब है कि return async ब्लॉक्स ब्लॉक से बाहर निकलते हैं, जबकि return try ब्लॉक युक्त फ़ंक्शन से बाहर निकलता है। हालांकि, ये कम से कम अलगाव में अर्थ रखते हैं, और async बिना जल्दी-वापसी या लेबल-ब्रेक-मूल्य का उपयोग करने के लिए बहुत कठिन होगा।

कुछ भी इस के स्थिरीकरण को रोकना, या अभी तक किसी ने भी इसे करने का समय नहीं लिया है? मुझे आवश्यक PR बनाने में दिलचस्पी है अन्यथा necessary

18 नवंबर, 2019 2:03:36 AM PST, Kampfkarren सूचनाएं @github.com ने लिखा:

इस के स्थिरीकरण को रोकने वाली कोई भी चीज, या सिर्फ किसी ने नहीं ली है
अभी तक यह करने के लिए समय? मुझे आवश्यक पीआर बनाने में दिलचस्पी है
अन्यथा 🙂>
>
->
आप इसका उल्लेख कर रहे हैं क्योंकि आपका उल्लेख किया गया था।>
इस ईमेल का उत्तर सीधे दें या इसे GitHub:> पर देखें
https://github.com/rust-lang/rust/issues/31436#issuecomment -554944079

हां, ओके-रैपिंग पर निर्णय के माध्यम से अवरोधक काम कर रहा है। इसे तब तक स्थिर नहीं किया जाना चाहिए जब तक हम इस बात पर एकमत न हों कि इसे कैसे व्यवहार करना चाहिए।

मैं व्यक्तिगत रूप से ओके-रैपिंग के खिलाफ हूं, लेकिन मैं सोच रहा हूं कि इस तथ्य को जोड़ना कितना कठिन होगा। क्या कोई ओके-रैपिंग ओके-रैपिंग के साथ संगत नहीं है?

मैं Result<Result<T,E>> की अस्पष्टता जैसे मुश्किल मामलों की कल्पना कर सकता हूं, लेकिन इस तरह के अस्पष्ट मामलों में, हम बिना किसी लपेट के वापस आ सकते हैं। उपयोगकर्ता तब स्पष्ट रूप से ठीक-ठीक नापसंद कर सकता था। यह बहुत बुरा नहीं लगता है, क्योंकि मैं इस तरह की अस्पष्टता की उम्मीद नहीं करता हूं कि यह बहुत बार आता है ...

इसमें बिल्कुल भी अस्पष्टता नहीं होनी चाहिए, क्योंकि यह Ok नहीं है, लेकिन Ok -wrapping है। try { ...; x } प्राप्त होते हैं Ok(x) बस के रूप में स्पष्ट रूप से के रूप में Ok({ ...; x }) ।

@joshtriplett क्या यह अनसुलझा है? Https://github.com/rust-lang/rust/issues/41414 का हवाला देते हुए ट्रैकिंग इश्यू में resolve whether catch blocks should "wrap" result value चेक किए गए हैं।

@rpjohnst क्षमा करें, मुझे अधिक स्पष्ट होना चाहिए था। मेरा मतलब यह है कि अगर हम ओके-रैपिंग के बिना try स्थिर करते हैं, तो मेरा मानना ​​है कि इसे बाद में पीछे की ओर जोड़ा जा सकता है।

यही है, मुझे लगता है कि ज्यादातर लोग सहमत हैं कि हमारे पास try ब्लॉक होना चाहिए, लेकिन हर कोई catch या ओके-रैपिंग के बारे में सहमत नहीं है। लेकिन मुझे नहीं लगता कि उन चर्चाओं को try ब्लॉक करने की आवश्यकता है ...

@Kampfkarren हाँ। उपरोक्त बातचीत में इस मामले की प्रगति का विवरण है। यह समय से पहले पूरी तरह से हर किसी से सलाह के बिना बंद किया गया था। @joshtriplett में विशेष रूप से चिंताएं थीं, जो कई अन्य (स्वयं सहित) साझा करते थे।

@ mark-im वास्तव में आप भविष्य में ओके-रैपिंग को कैसे जोड़ते हैं? मैं यह पता लगाने की कोशिश कर रहा हूं कि यह कैसे किया जा सकता है, और मैं इसे नहीं देख सकता।

इसलिए मैं इसे यह कहकर प्रस्तुत करूंगा कि मुझे नहीं पता कि यह एक अच्छा विचार है या नहीं ...

हम ओके-रैपिंग के बिना try ब्लॉक को स्थिर करेंगे। उदाहरण के लिए:

let x: Result<usize, E> = try { 3 }; // Error: expected Result, found usize
let x: Result<usize, E> = try { Ok(3) }; // Ok (no pun intended)

बाद में, मान लीजिए कि हम सर्वसम्मति से आए कि हमारे पास ओके-रैपिंग होनी चाहिए, तो हम कुछ मामलों की अनुमति दे सकते हैं जो पहले काम नहीं करते थे:

let x: Result<usize, E> = try { 3 }; // Ok
let x: Result<usize, E> = try { Ok(3) }; // Also Ok for backwards compat
let x: Result<Result<usize, E1>, E2> = try { Ok(3) }; // Ok(Ok(3))
let x: Result<Result<usize, E1>, E2> = try { Ok(Ok(3)) }; // Ok(Ok(3))

सवाल यह है कि क्या इससे कुछ अस्पष्ट हो सकता है जो पहले नहीं था। उदाहरण के लिए:

let x = try { Err(3) }; // If x: Result<Result<T1, usize>, usize>, then it is not clear if user meant Ok(Err(3)) or Err(3)...

हालांकि, शायद ओके-रैपिंग में पहले से ही इस समस्या से जूझना पड़ता है?

वैसे भी, मेरा अंतर्ज्ञान यह है कि ऐसे अजीब मामले अक्सर सामने नहीं आते हैं, इसलिए यह उतना मायने नहीं रखता है।

ओके-रैपिंग का उपयोग करने के बारे में क्या है, जहां छोड़कर लौटे प्रकार Result या Option ? यह ज्यादातर मामलों में सरल कोड की अनुमति देगा, लेकिन जहां आवश्यक हो, सटीक मूल्य निर्दिष्ट करने की अनुमति देगा।

// Ok-wrapped
let v: Result<i32, _> = try { 1 };

// not Ok-wrapped since the returned type is Result
let v: Result<i32, _> = try { Ok(1) };

// not Ok-wrapped since the returned type is Result
let v: Result<i32, _> = try { Err("error") };

// Ok-wrapped
let v: Option<i32> = try { 1 };

// not Ok-wrapped since the returned type is Option
let v: Option<i32> = try { Some(1) };

// not Ok-wrapped since the returned type is Option
let v: Option<i32> = try { None };

Ok -कोर्सियन या किसी प्रकार के सिंटैक्स पर निर्भर Ok -प्रपोजिंग (जो कि इसके बिना स्थिरीकरण का समर्थन करने और बाद में इसे शुरू करने के लिए क्या करना होगा) पठनीयता के लिए बहुत बुरा होगा, और मोटे तौर पर i.rl.o पर कई बार के खिलाफ तर्क दिया गया है (आमतौर पर लोग सीधे Ok -wrapping जो इसे लागू किया गया है) को गलत समझ रहे हैं।

मैं व्यक्तिगत रूप से Ok पक्ष में जोरदार तरीके से लागू कर रहा हूं, लेकिन किसी भी रूप में जोर-जबरदस्ती या वाक्यविन्यास निर्भरता के खिलाफ होगा जो उन परिस्थितियों को समझने में सक्षम बनाता है जो मुश्किल लपेटेंगे (मुझे बेकार लिखना होगा) Ok(...) हर जगह कोशिश करने और यह पता लगाने के लिए कि क्या उसके पास होने या न होने पर)।

let x = try { Err(3) }; // If x: Result<Result<T1, usize>, usize>, then it is not clear if user meant Ok(Err(3)) or Err(3)...

हालांकि, शायद ओके-रैपिंग में पहले से ही इस समस्या से जूझना पड़ता है?

नहींं, जो कि स्पष्ट रूप से Ok(Err(3)) , Ok -wrapping सिंटैक्स या प्रकारों से स्वतंत्र है, यह सिर्फ ब्लॉक के आउटपुट Try::Ok जो भी लपेटता है।

@ mark-im मुझे नहीं लगता कि हम स्थिरीकरण के बाद एक से दूसरे में जा सकते हैं। जैसा कि मैं ओके-रैपिंग को बुरा मानता हूं, असंगत ओके-रैपिंग जो यह अनुमान लगाने की कोशिश करता है कि आप इसे चाहते हैं या नहीं और भी बुरा होगा।

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

मेरे पास एक टन वैकल्पिक मूल्य हैं, जिनके साथ मुझे काम करने की आवश्यकता है, और वे ज्यादातर संख्यात्मक हैं, इसलिए मेरे पास इस तरह की स्थितियों के टन हैं:

let c = try { 2 * a? + b? };

ओके-रैपिंग के बिना यह उस बिंदु पर बहुत कम एर्गोनोमिक होगा जहां मैं वास्तविक कोशिश ब्लॉकों का उपयोग करने की तुलना में अपने स्वयं के मैक्रो पर रहने की संभावना होगी।

इस ट्रैकिंग मुद्दे के आदरणीय इतिहास को देखते हुए, ? ऑपरेटर के साथ इसके मूल और अफसोसजनक अनुमान, और Ok -wrapping मुद्दे पर रोक, मैं इस मुद्दे को एकमुश्त बंद करने और try भेजने का सुझाव दूंगा RFC प्रक्रिया की शुरुआत में

ओके-रैपिंग के बिना यह बहुत कम एर्गोनोमिक होगा

क्या आप इस बात पर विस्तार से बता सकते हैं कि यह वास्तव में गैर-एर्गोनोमिक सामान क्या होगा?

ओके-रैपिंग के बिना, आपका उदाहरण ऐसा दिखेगा:

let c = try { Ok(2 * a? + b?) };

जो मेरी राय में बहुत अच्छा है।

मेरा मतलब है, इस तरह के एक छोटे से उदाहरण के साथ यह ओवरकिल की तरह लग सकता है लेकिन अधिक कोड try ब्लॉक इस Ok(...) रैपर कारणों का कम प्रभाव डालता है।

@CreepySkeleton की टिप्पणी के आगे, यह ध्यान दिया जाना चाहिए कि एक मैक्रो बनाना बहुत आसान है जो Ok अनुकरण करता है यदि try ब्लॉक ऐसा नहीं करता (और कोई निश्चित रूप से बनाएगा) इस छोटे मैक्रो के लिए एक मानक टोकरा), लेकिन काफिला ऐसा नहीं है।

यह मैक्रो संभव नहीं है, जबकि Try विशेषता अस्थिर है।

क्यों? वैसे भी, जब यह स्थिर हो जाता है (भविष्य में काल्पनिक रूप से बहुत दूर नहीं), तो यह बहुत संभव होगा।

@ निमो 157 try ब्लॉक भी अभी केवल रात में हैं, और वे संभावना नहीं की संभावना के मामले में स्थिर हो जाएंगे कि हम Try चीर करने का फैसला करते हैं। इसका मतलब यह है कि वे Try पहले स्थिर नहीं होंगे। इसलिए, मैक्रो संभव नहीं है कहने का मतलब नहीं है।

@ कृष्णसनासी मैं उत्सुक हूं कि Try क्यों निकाला जा सकता है?

@ mark-im मुझे नहीं लगता कि, मैं सिर्फ यही समझा रहा हूं कि क्यों Try रात को परेशान करने की कोशिश करना ब्लॉक करने की कोशिश करना एक यथार्थवादी चिंता नहीं है। मैं Try स्थिर पर आगे देख रहा हूं।

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

(_Why_ के लिए आप यह नहीं लिख सकते कि स्थूल दिए गए try ब्लॉक और एक अस्थिर Try विशेषता है, मैक्रो का विस्तार try { Try::from_ok($expr) } ; आप प्रति-प्रकार मैक्रोज़ बना सकते हैं; सिर्फ Result और Option , लेकिन IMO जो "बहुत आसान [...] अनुकरण" बिंदु को पूरा नहीं करेगा।

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

मैं सुझाव दे सकता हूँ निम्नलिखित अवधारणा को पकड़ने के लिए अर्थ ...

निम्नलिखित कोड पर विचार करें:

union SomeFunctionMultipleError {
    err0: Error1,
    err1: Error2,
}

struct SomeFunctionFnError {
    index: u32,
    errors: SomeFunctionMultipleError,
}

fn some_function() -> Result<i32, SomeFunctionFnError> {
    if 0 == 0 {
        Ok(2)
    } else {
        Err(SomeFunctionFnError{ index: 0, errors: SomeFunctionMultipleError {err1: Error2 {id0: 0, id1: 0, id3: 0}}})
    }
}

union OtherFunctionMultipleError {
    err0: Error1,
    err1: Error2,
    err2: Error3,
}

struct OtherFunctionFnError {
    id: u32,
    errors: OtherFunctionMultipleError,
}

fn other_function() -> Result<i32, OtherFunctionFnError> {
    if 0 == 0 {
        Ok(2)
    } else {
        Err(OtherFunctionFnError {id: 0, errors: OtherFunctionMultipleError {err0: Error1 {id0: 0, id1: 0}}})
    }
}

यह वह कोड है जो निम्नलिखित सिंटैक्स सुविधा के साथ जंग में शून्य-ओवरहेड अपवादों द्वारा उत्पन्न किया जा सकता है:

fn some_function() -> i32 throws Error1, Error2 {
    if 0 == 0 {
        2
    } else {
        Error2 {id0: 0, id1: 0, id3: 0}.throw
    }
}

fn other_function() -> i32 throws Error1, Error2, Error3 {
    if 0 == 0 {
        2
    } else {
        Error1{id0: 0, id1: 0}.throw
    }
}

या यहां तक ​​कि इन त्रुटियों को संकलक द्वारा अनुमानित रूप से घटाया जा सकता है:

fn some_function(i: i32) -> i32 throws { // Implicitly throws Error1, Error2
    if i == 0 {
        2
    } else if i == 1 {
        Error1 {id0: 0, id1: 0, id3: 0}.throw
    } else {
        Error2 {id0: 0, id1: 0, id3: 0}.throw
    }
}

fn other_function(i: i32) -> i32 throws { // Implicitly throws Error1
    if i == 0 {
        2
    } else {
        Error1{id0: 0, id1: 0}.throw
    }
}

यह और कुछ नहीं सिंथेटिक चीनी !! व्यवहार वही है !!

नमस्ते,

क्या किसी ने जीरो-ओवरहेड अपवादों के बारे में मेरा प्रस्ताव देखा है जो ऊपर है?

@redradist try ब्लॉक के मुख्य बिंदुओं में से एक यह है कि हम इसे

बस आज मुझे try ब्लॉक की आवश्यकता महसूस हुई। मेरा एक बड़ा कार्य है जिसमें कई ? संचालन हैं। मैं त्रुटियों के संदर्भ को जोड़ना चाहता था, लेकिन प्रत्येक ? लिए ऐसा करने से बॉयलरप्लेट की एक बड़ी राशि की आवश्यकता होती। try साथ त्रुटियों को पकड़ना और संदर्भ को एक स्थान पर जोड़ने से इसे रोका जा सकता था।

Btw। एक आंतरिक कार्य में संचालन को लपेटना इस मामले में कठिन होता, क्योंकि संदर्भ में स्पष्ट जीवनकाल नहीं होता है, और सामान को कई कार्यों में विभाजित करने से एनएलएल टूट जाता है।

मैं यह उल्लेख करना चाहूंगा कि वर्तमान कार्यान्वयन में try ब्लॉक एक अभिव्यक्ति नहीं है। सोचें कि यह एक निरीक्षण है।

मैं यह उल्लेख करना चाहूंगा कि वर्तमान कार्यान्वयन में एक कोशिश ब्लॉक एक अभिव्यक्ति नहीं है। सोचें कि यह एक निरीक्षण है।

क्या आप उस कोड को पोस्ट कर सकते हैं जो आपके लिए काम नहीं कर रहा है? मैं इसे एक अभिव्यक्ति के संदर्भ में यहाँ उपयोग करने में सक्षम हूँ: ( जंग का मैदान )

#![feature(try_blocks)]

fn main() {
    let s: Result<(), ()> = try { () };
}

ज़रूर, यहाँ यह है ।

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

@ Nokel81 आपके पूर्व उदाहरण के साथ समस्या यह है कि if let $pat = $expr में अभिव्यक्ति एक नियमित अभिव्यक्ति संदर्भ नहीं है, बल्कि एक विशेष "कोई कोष्ठक अभिव्यक्ति" संदर्भ नहीं है। यह कैसे संरचनात्मक अभिव्यक्तियों के साथ काम करता है, इस उदाहरण के लिए , यह उदाहरण जहां यह नहीं है। तो त्रुटि यह नहीं है कि try एक अभिव्यक्ति नहीं है, लेकिन यह है कि त्रुटि गलत है, और कहना चाहिए " try अभिव्यक्ति को यहां अनुमति नहीं है, इसे कोष्ठक के साथ आसपास की कोशिश करें" (और अनावश्यक कोष्ठक के बारे में गलत चेतावनी दबी हुई)।

आपका बाद का उदाहरण वास्तव में प्रकार के अनुमान के लिए अस्पष्ट है। e का प्रकार इस मामले में _: From<usize> है, जो इसे ठोस प्रकार देने के लिए पर्याप्त जानकारी नहीं है। आपको इसे किसी प्रकार का ताकि इसे टाइप करने के लिए सफल होने की अनुमति दी जा सके। यह try लिए विशिष्ट मुद्दा नहीं है; यह बताता है कि जंग में किस प्रकार का अनुमान काम करता है।

अब, यदि आप तुरंत Ok रूप में मिलान करने का प्रयास करते हैं और Err केस को छोड़ देते हैं , तो आपके पास इसे संबोधित करने के लिए कोई वास्तविक है ।

गहराई से स्पष्टीकरण के लिए आह धन्यवाद। मुझे लगता है कि मैं अभी भी उलझन में हूं कि बाद में टाइप इंट्रेंस के लिए अस्पष्ट क्यों हूं। अभिव्यक्ति का प्रकार Result<isize, usize> क्यों नहीं है?

? ऑपरेटर From विशेषता का उपयोग करके विभिन्न त्रुटि प्रकारों के बीच प्रकार रूपांतरण कर सकते हैं। यह मोटे तौर पर निम्नलिखित जंग कोड तक फैलता है ( Try विशेषता को अनदेखा करता है):

match expr {
    Ok(v) => v,
    Err(e) => return From::from(e),
}

From कॉल, किस प्रकार के रूपांतरणों को करने के लिए निर्धारित करने के लिए अंतिम लौटे हुए अभिव्यक्ति के प्रकार का उपयोग करता है, और स्वचालित रूप से पारित मूल्य के प्रकार के लिए डिफ़ॉल्ट नहीं होगा।

माफी अगर यह पहले से ही संबोधित किया गया है, लेकिन यह मुझे अजीब लगता है कि:

#![feature(try_blocks)]

fn main() -> Result<(), ()> {
    let result = try { // no type annotation
        Err(())?;
    };
    result.map_err(|err| err)
}

इसके साथ संकलन करने में विफल:

error[E0282]: type annotations needed

परंतु:

#![feature(try_blocks)]

fn main() -> Result<(), ()> {
    let result : Result<_, _> = try { // partial type annotation
        Err(())?;
    };
    result.map_err(|err| err)
}

ठीक है।

यदि यह एक समस्या थी, क्योंकि Result की दलीलें कम नहीं की जा सकती थीं, तो मैं समझ पाऊंगा, लेकिन, जैसा कि ऊपर दिखाया गया है, यह मामला नहीं है और जंग एक बार निष्कर्ष निकालने में सक्षम है, क्योंकि यह बताया गया है कि परिणाम एक try अभिव्यक्ति Result कुछ प्रकार है, जो core::ops::Try::into_result से अनुमान लगाने में सक्षम होना चाहिए।

विचार?

@nwsharp ऐसा इसलिए है क्योंकि try / ? Try प्रकार से अधिक सामान्य है। यदि आपके पास कुछ अन्य प्रकार था जो impl Try<Ok=_, Error=()> , तो कोशिश करें कि ब्लॉक उस प्रकार के साथ ही Result मूल्यांकन कर सके। वर्णन किया गया है, आपका उदाहरण मोटे तौर पर है

#![feature(try_trait, label_break_value)]

use std::ops::Try;

fn main() -> Result<(), ()> {
    let result /*: Result<_, _>*/ = 'block: {
        match Try::into_result(Err(())) {
            Ok(ok) => Try::from_ok(ok),
            Err(err) => {
                break 'block Try::from_error(From::from(err));
            }
        }
    };
    result.map_err(|err| err)
}

@ CAD97 स्पष्टीकरण के लिए धन्यवाद।

उस ने कहा, मुझे उम्मीद नहीं थी कि try प्रभावी रूप से अलग-अलग Try बीच रूपांतरण करने में सक्षम होंगे।

मुझे उम्मीद है कि एक Try into_result , from_ok , और from_error लिए एक de-surgaring की उम्मीद है।

मेरी राय में, एर्गोनोमिक नुकसान प्रकार की निष्कासन करने में असमर्थ होने के कारण (विशेष रूप से यह देखते हुए कि कोई वैकल्पिक impl Try भी मौजूद है), इस रूपांतरण की अनुमति देने के लाभ से आगे नहीं निकलता है।

हम अस्पष्टता को दूर करके निष्कर्ष निकालने की अनुमति दे सकते हैं, और रूपांतरण में ऑप्ट-इन करने की क्षमता रख सकते हैं जैसे कि:

try { ... }.into()

संबंधित कंबल के साथ:

impl<T: Try, E: Into<T::Err>> From<Result<T::Ok, E>> for T {
    fn from(result: Result<T::Ok, E>) -> Self {
        match result {
            Ok(ok) => T::from_ok(ok),
            Err(err) => T::from_err(err.into()),
        }
    }
}

(जो ईमानदारी से मुझे लगता है कि समझ में आता है, हालांकि मैं व्यक्तिगत रूप से यहाँ त्रुटि प्रकारों के स्वत: रूपांतरण पर संदेह करता हूं। अगर यह चाहता है, तो उपयोगकर्ता को .map_err() Result ।)

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

या, कंबल के साथ और भी आगे जा रहा है, मुझे लगता है।

impl <T: Try, U: Try> From<U> for T 
    where U::Ok : Into<T::Ok>, U::Err : Into<T::Err>
{
    fn from(other: U) -> Self {
        match other.into_result() {
            Ok(ok) => Self::from_ok(ok.into()),
            Err(err) => Self::from_err(err.into()),
        }
    }
}

जो कुछ भी...

उस ने कहा, मुझे उम्मीद नहीं थी कि कोशिश प्रभावी रूप से भिन्न Try बीच रूपांतरण का कारण बनने में सक्षम होगी।

मुझे उम्मीद है कि एक Try into_result , from_ok , और from_error लिए चयनित होने की उम्मीद है।

मेरी राय में, एर्गोनोमिक नुकसान प्रकार की निष्कासन करने में असमर्थ होने के कारण (विशेष रूप से यह देखते हुए कि कोई वैकल्पिक impl Try भी मौजूद है), इस रूपांतरण की अनुमति देने के लाभ से आगे नहीं निकलता है।

चार स्थिर Try प्रकार हैं: Option<T> , Result<T, E> , Poll<Result<T, E>> , और Poll<Option<Result<T, E>> ।

NoneError अस्थिर है, इसलिए Option<T> Option<T> में कोशिश कर रहा है, जबकि NoneError अस्थिर है। (ध्यान दें कि डॉक्स स्पष्ट रूप से From<NoneError> को "अपनी त्रुटि प्रकार के लिए option? सक्षम करें") कहते हैं।

Poll निहित है, हालाँकि, उनकी त्रुटि प्रकार E । इस वजह से, Try का "टाइप मॉर्फिंग" स्थिर है, क्योंकि आप ? Poll<Result<T, E>> -> Result<_, E> Poll<T> पाने के लिए कर सकते हैं। E केस वापस।

वास्तव में, इस शक्ति एक "प्यारा" छोटे सहायक :

fn lift_err<T, E>(x: Poll<Result<T, E>>) -> Result<Poll<T>, E> { Ok(x?) }

@ CAD97 मुझे

क्या यहां पर अप्रयुक्त व्यवहार को आत्मसात करने के लिए वांछित impl Try के विनिर्देशन की अनुमति देने के बारे में सोचा गया है?

उदाहरण के लिए, एक बिट के लिए बिकेशिंग, try<T> { ... } । या वहाँ अभी भी फिर से उस के साथ यात्रा करने के लिए कुछ है?

शायद यहाँ थोड़ा और रंग जोड़ सकते हैं, यह तथ्य कि try { } एक गुच्छा Result " Result उत्पादन अप्रत्याशित है और मुझे दुखी करता है । मैं समझता हूँ क्यों , लेकिन मुझे यह पसंद नहीं है।

हां, "सामान्यीकृत प्रकार के लिखावट" के संयोजन की चर्चा हुई है (आपकी खोज करने के लिए आपका कार्यकाल है) और try । मुझे लगता है, आखिरी बार मैंने सुना, try: Result<_, _> { .. } अंततः काम करने का इरादा था।

लेकिन मैं आपसे सहमत हूं: try ब्लॉक कुछ लक्षित निदान के लिए सुनिश्चित करते हैं कि उनका आउटपुट प्रकार निर्दिष्ट है।

कृपया Ok -wrapping के मामले पर भाषा टीम की सहमति को हल करने के लिए एक विशिष्ट संकीर्ण प्रश्न के लिए इस अलग मुद्दे को देखें।

टिप्पणी करने से पहले कृपया उस धागे की प्रारंभिक टिप्पणी पढ़ें, और विशेष रूप से, कृपया ध्यान दें कि वह धागा केवल उस एक प्रश्न के बारे में है, न कि try या ? या Try से संबंधित कोई अन्य मुद्दा।

मैं नहीं देखता कि try ब्लॉक की आवश्यकता क्यों है। यह वाक्य रचना

fn main() -> Result<(), ()> {
    try {
        if foo() {
            Err(())?
        }
        ()
    }
}

इसे इसके साथ बदला जा सकता है:

fn main() -> Result<(), ()> {
    Ok({
        if foo() {
            Err(())?
        }
        ()
    })
}

वे दोनों समान वर्णों का उपयोग करते हैं, लेकिन दूसरा पहले से ही स्थिर है।

परिणाम को एक चर में नियत करते समय, जो यह संकेत दे सकता है कि परिणाम वापस करने के लिए एक सहायक फ़ंक्शन बनाया जाना चाहिए। यदि यह संभव नहीं है, तो इसके बजाय एक बंद का उपयोग किया जा सकता है।

@dylni try ब्लॉक विशेष रूप से तब उपयोगी होते हैं जब उनमें किसी फ़ंक्शन का संपूर्ण शरीर नहीं होता है। ? ऑपरेटर त्रुटि पर प्रवाह नियंत्रण बनाता है जो अंत में सबसे आंतरिक try ब्लॉक के अंत तक जाता है, फ़ंक्शन से वापस आए बिना।

`` `जंग
fn main () / * यहाँ कोई परिणाम नहीं * / {
परिणाम देना = प्रयास करना {
foo () ?. बार () ?. baz ()?
};
मैच का परिणाम {
//…
}
}

@SimonSapin क्या वह अक्सर आता है? मेरे पास शायद ही कोई ऐसी स्थिति है जिसके लिए यह समझ में आता है, और आमतौर पर इसके चारों ओर एक अच्छा तरीका है। आपके उदाहरण में:

fn main() /* no result here */ {
    let result  = foo()
        .and_then(|x| x.bar())
        .and_then(|x| x.baz());
    match result {
        // …
    }
}

यह अधिक क्रिया है, लेकिन मुझे लगता है कि एक सरल समाधान एक विधि बंद वाक्यविन्यास होगा:

fn main() /* no result here */ {
    let result  = foo()
        .and_then(::bar)
        .and_then(::baz);
    match result {
        // …
    }
}

प्रकार भी and_then साथ सही ढंग से अनुमान लगाया गया है, जहां आपको try लिए प्रकार एनोटेशन की आवश्यकता है। मैंने यह पर्याप्त रूप से पर्याप्त रूप से पाया है कि मुझे नहीं लगता कि एक टेरियर सिंटैक्स पठनीयता नुकसान के लायक होगा।

स्वीकृत RFC के कुछ और तर्क हैं: https://rust-lang.github.io/rfcs/0243-trait-based-exception-handling.html

वैसे भी भाषा के पक्ष में तर्क ? (और .await ) के साथ नियंत्रण प्रवाह के लिए ऑपरेटर and_then तरह तरीकों का पीछा करते हुए पहले ही बड़े पैमाने पर चर्चा कर चुके हैं।

वैसे भी भाषा के पक्ष में तर्क ? (और .await ) के साथ नियंत्रण प्रवाह के लिए ऑपरेटर and_then तरह तरीकों का पीछा करते हुए पहले ही बड़े पैमाने पर चर्चा कर चुके हैं।

@SimonSapin धन्यवाद। यह और फिर से पढ़ना आरएफसी ने मुझे आश्वस्त किया कि यह उपयोगी हो सकता है।

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

मैंने एक छोटा सा फंक्शन लिखा जो ठीक काम करता है। ध्यान दें कि File::open()? std::io::Error साथ विफल रहता है, जबकि निम्न पंक्ति anyhow::Error साथ विफल हो जाती है। अलग-अलग प्रकारों के बावजूद, कंपाइलर यह पता लगाता है कि दोनों को Result<_, anyhow::Error> कैसे परिवर्तित किया जाए।

fn tls_add_cert(config: &ClientConfig, path: impl AsRef<Path>) -> Result<(usize, usize), anyhow::Error> {
    let path = path.as_ref();
    let mut file = BufReader::new(File::open(path)?);
    Ok(config.root_store.add_pem_file(&mut file)
        .map_err(|_| anyhow!("Bad PEM file"))?)
}

मैं कुछ त्रुटि संदर्भ जोड़ना चाहता था, इसलिए मैंने एक कोशिश ब्लॉक और किसी भी तरह with_context() का उपयोग करने की कोशिश की:

fn tls_add_cert(config: &ClientConfig, path: impl AsRef<Path>) -> anyhow::Result<(usize, usize)> {
    let path = path.as_ref();
    try {
        let mut file = BufReader::new(File::open(path)?);
        Ok(config.root_store.add_pem_file(&mut file)
            .map_err(|_| anyhow!("Bad PEM file"))?)
    }
    .with_context(|| format!("Error adding certificate {}", path.display()))
}

लेकिन अब प्रकार निष्कासन विफल रहता है:

error[E0282]: type annotations needed
  --> src/net.rs:29:5
   |
29 | /     try {
30 | |         let mut file = BufReader::new(File::open(path)?);
31 | |         Ok(config.root_store.add_pem_file(&mut file)
32 | |             .map_err(|_| anyhow!("Bad PEM file"))?)
33 | |     }
   | |_____^ cannot infer type
   |
   = note: type must be known at this point
   ```

I don't understand why a type annotation is needed here but not in the first case. Nor do I see any easy way to add one, as opposed to using an [IIFE](https://en.wikipedia.org/wiki/Immediately_invoked_function_expression) which does let me add an annotation:

```rust
(|| -> Result<_, anyhow::Error> {
    let domain = DNSNameRef::try_from_ascii_str(host)?;
    let tcp = TcpStream::connect(&(host, port)).await?;

    Ok(tls.connect(domain, tcp).await?)
})()
.with_context(|| format!("Error connecting to {}:{}", host, port))

@jkugelman

फिर,

ऐसा इसलिए है क्योंकि try / ? Try प्रकार से अधिक सामान्य है। यदि आपके पास कुछ अन्य प्रकार थे जो [ impl Try<Ok=_, Error=anyhow::Error> ] थे, तो कोशिश करें कि ब्लॉक उस प्रकार के साथ ही Result मूल्यांकन कर सके।

(इसके अलावा, आपको try ब्लॉक (# 70941) में Ok अपनी अनुगामी अभिव्यक्ति की आवश्यकता नहीं है।)

मुझे लगता है कि तथ्य यह है कि यह दिखाने के लिए जारी है कि इसका मतलब है

• स्थिरीकरण से पहले, try को एक प्रकार के लेखन का समर्थन करने की आवश्यकता है ( try: Result<_,_> { या जो भी हो) या अन्यथा इस मुद्दे को कम करें,
• जब try ब्लॉक विफल हो जाता है, और इसके प्रकार का अनुमान लगाने के लिए निश्चित रूप से लक्षित निदान की आवश्यकता होती है
• जब हम अन्यथा विवश नहीं होते हैं, तो हमें try Result<_,_> एक प्रकार का कमबैक देने पर जोर देना चाहिए। हां, यह मुश्किल है, के तहत निर्दिष्ट, और संभावित रूप से समस्या है, लेकिन यह के 80% मामले का समाधान _would_ try ब्लॉक की वजह से एक प्रकार एनोटेशन जरूरत $12: Try<Ok=$5, Error=$8> नहीं किया जा रहा विशिष्ट पर्याप्त।

इसके अतिरिक्त, दिया गया # 70941 "हां, हम चाहते हैं (कुछ रूप) ' Try::from_ok रैपिंग' की ओर बढ़ रहा है, हम शायद _also_ के लिए एक लक्षित डायग्नोस्टिक चाहते हैं जब try अभिव्यक्ति हो Ok(x) लौट रहा है जब x काम करेगा।

मुझे संदेह है कि कोशिश के लिए सही व्यवहार है

• try: Result<_, _> { .. } , try as Result<> , या जो कुछ भी मुझे लगता है (मैं try: Result शायद ठीक है? जैसा लगता है कि यह पसंदीदा सिंटैक्स लगता है)
• संदर्भ से आने वाले "अपेक्षित प्रकार" की जांच करें - यदि कोई मौजूद है, तो परिणाम पसंद करें कि try के परिणाम प्रकार के रूप में
• अन्यथा, Result<_, _> लिए डिफ़ॉल्ट - यह i32 साथ एक प्रकार की गिरावट नहीं है, यह पहले होगा, लेकिन इसका मतलब यह होगा कि try { }.with_context(...) संकलन जैसी चीजें।

हालाँकि, मुझे इस बात की चिंता है कि हमें ? और into ज़ब्ती के रूप में त्रुटियां मिल सकती हैं, कम से कम इतने लंबे समय तक जब तक कि त्रुटि प्रकार निर्दिष्ट न हो। विशेष रूप से यदि आप कोड लिखते हैं जहां आप ? try ब्लॉक का परिणाम पसंद करते हैं, तो:

#![feature(try_blocks)]

use std::error::Error;
fn foo() -> Result<(), Box<dyn Error>> {
    let x: Result<_, _> = try {
        std::fs::File::open("foo")?;
    };

    x?;

    Ok(())
}

fn main() { 
}

आपको अभी भी त्रुटियां ( खेल का मैदान ) मिलती हैं और ठीक ही है, क्योंकि यह स्पष्ट नहीं है कि ? "में" किसके लिए ट्रिगर होना चाहिए।

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

संभवत: इसमें कुछ प्रकार के इंफेक्शन फॉलबैक शामिल हैं जो मुझे परेशान कर देंगे।

सबसे सरल एक: यदि दिए गए Try ब्लॉक में ? सभी उपयोगों में समान Try::Error प्रकार होते हैं, तो उस त्रुटि प्रकार का उपयोग try ब्लॉक के लिए करें (जब तक कि अन्यथा बंधे हुए)।

"(जब तक कि अन्यथा बाध्य नहीं हो)", निश्चित रूप से, सूक्ष्म डरावना हिस्सा है।

मुझे उम्मीद है कि मैं इस पोस्ट के साथ बहुत असंवैधानिक नहीं हूं। हालांकि, मैं एक समानांतर दुनिया से एक के साथ @nikomatsakis उदाहरण विपरीत करना चाहता था जहां ? एक जबरन रूपांतरण नहीं करता है, और try ब्लॉक परिणाम का कोई ऑटो-रैपिंग नहीं है:

use std::error::Error;
fn foo() -> Result<(), Box<dyn Error>> {
    let x = try {
        std::fs::File::open("foo").err_convert()?;
        Ok(())
    };

    x?;

    Ok(())
}

इस दुनिया में:

• यह देखना आसान है कि दोनों try स्कोप और fn परिणाम बिना किसी मूल्य के सफलता है। यह भी देखने की कोशिश के बिना यह देखना आसान है कि वे Result उत्पादन करते हैं।
• यह स्पष्ट है कि त्रुटि रूपांतरण कहां होता है।
• त्रुटि रूपांतरण x? अभिव्यक्ति में ले जाया जा सकता है, जिससे try स्कोप std::fs::File परिचालन के लिए विशिष्ट हो जाता है।
• सभी प्रकार के हस्ताक्षर से हस्ताक्षर से धाराप्रवाह संकेत मिलता है। मशीन के लिए और हम इंसानों के लिए।
• उपयोगकर्ता द्वारा टाइप की गई हिंटिंग केवल उन मामलों में आवश्यक है जहां हम वास्तव में त्रुटियों को दूसरे, स्वतंत्र एक में बदलना चाहते हैं।

मुझे उस समानांतर ब्रह्मांड में बहुत खुशी होगी।

@phaylon जब मैं सावधान जिस तरह से आप उस टिप्पणी लिखना सराहनीय, मुझे डर लग रहा है कि यह नहीं बल्कि unconstructive है। त्रुटि रूपांतरण ? का हिस्सा है और यह बदलने वाला नहीं है, और इसके प्रकाश में, ओके-रैपिंग मूल रूप से इस चर्चा के बाकी हिस्सों से रूढ़िवादी है।

यदि try फ़ंक्शंस (रिटर्न और थ्रो प्रकार के साथ) पर कभी विचार किया जाता है, तो शायद यह भी ब्लॉक के समान होने के लिए सिंटैक्स पर विचार करने के लायक होगा।

जैसे

try fn foo() -> u32 throw String {
  let result = try: u32 throw String {
    123
  };
  result?
}

क्षमा करें यदि यह चर्चा की गई है, लेकिन उपयोग करने के क्या फायदे हैं

try fn foo() -> u32 throw String { ... }

या के समान विरोध किया

fn foo() -> Result<u32, String> { ... }

?
बस डुप्लिकेट वाक्य रचना की तरह लगता है।

@gorilskij जैसा कि मैं इसे समझता हूं, प्राथमिक लाभ Ok -wrapping प्राप्त करना है। अन्यथा, आपको लिखना होगा:

fn foo() -> Result<u32, String> {
    try {
        // function body
    }
}

कुछ लोग throws भी पसंद करते हैं क्योंकि वे अपवाद शब्दावली को भरोसेमंद पाते हैं।

व्यक्तिगत रूप से, मैं अपवादों की उपस्थिति से यथासंभव दूर रहना चाहता हूं।

यह try fn पर चर्चा करने के लिए धागा नहीं है, इसलिए कृपया इस स्पर्शरेखा को और न लें। यह धागा try ब्लॉक की स्वीकृत सुविधा के लिए है, न कि संभावित (और अभी तक, RFCd के रूप में) try fn ।

मैं सिर्फ देखा है कि के लिए मूल आरएफसी ? प्रस्तावित का उपयोग कर Into , नहीं From । य़ह कहता है:

वर्तमान RFC इस उद्देश्य के लिए std::convert::Into का उपयोग करता है (जिसमें From से अग्रेषित करने वाला कंबल है)।

हालांकि एक सटीक प्रश्न के रूप में सटीक उत्थान विधि को छोड़ देता है। Into (संभवतः) From के मार्गदर्शन के आधार पर पसंद किया गया था:

एक सामान्य कार्य पर विशेषता सीमा को निर्दिष्ट करते समय From का उपयोग करके Into का उपयोग करना पसंद करें। इस प्रकार, प्रकार जो सीधे Into हैं, उनका उपयोग तर्कों के रूप में भी किया जा सकता है।

हालांकि, Try trait RFC में , Into का उल्लेख नहीं किया जाता है, और रूपांतरण From का उपयोग करके किया जाता है। यह वह भी है जो अब कोड का उपयोग करता है, यहां तक ​​कि ?
https://github.com/rust-lang/rust/blob/b613c989594f1cbf0d4af1a7a153786cca7792c8/src/librustc_ast_lowering/expr.rs#L1232

यह दुर्भाग्यपूर्ण लगता है, क्योंकि Into से From होने वाला कोई कंबल कार्यान्वयन नहीं है। इसका अर्थ यह है कि या तो त्रुटि के कारण Into ( From विपरीत) लागू होने वाली त्रुटियां, विरासत की वजहों से, या कुछ अन्य आवश्यकताओं के लिए, ? (या) के साथ उपयोग नहीं की जा सकती हैं Try )। इसका यह भी अर्थ है कि मानक पुस्तकालय में Into का उपयोग करने के लिए किसी भी कार्यान्वयन का पालन करने वाली सीमा ? उपयोग नहीं कर सकती है। एक उदाहरण के साथ, मानक पुस्तकालय मुझे लिखने की सलाह देता है:

fn with_user_err<E>(op: impl Fn() -> Result<(), E>) -> Result<(), MyError>
where E: Into<MyError>

लेकिन अगर मैं करता हूं, तो मैं फ़ंक्शन बॉडी में ? का उपयोग नहीं कर सकता। अगर मैं ऐसा करना चाहता हूं, तो मुझे लिखना होगा

fn with_user_err<E>(op: impl Fn() -> Result<(), E>) -> Result<(), MyError>
where MyError: From<E>

लेकिन अगर मैं करता हूं, तो त्रुटि प्रकार वाले उपयोगकर्ता Into करने के बजाय From इस फ़ंक्शन का उपयोग नहीं कर सकते हैं। ध्यान दें कि उलटा की कंबल impl की वजह से, सच नहीं है Into के आधार पर From ।

शायद ? ( Try में उस रास्ते को गहरा नहीं खोदना चाहिए?

@ जोंहू @cuviper ने From 60 Into 60796 में # 38751 की जाँच करने के लिए अवरोही को बदलने की कोशिश की और इससे From वजह से बड़ी मात्रा में अंतर्ग्रहण टूट गया। -> Into कंबल निहित ने जंग के लिए पहचान रूपांतरण के सामान्य मामले को संभालना कठिन बना दिया। यह तय किया गया था कि यह लागत ब्रेकिंग अनुमान के लायक नहीं था।

@ जानू आपको भी यह टिप्पणी

विशेषता प्रणाली में एक हार्ड-कोडित सीमा भी है। यदि आपको ?X: Into<ReturnType> जैसे लक्ष्य को हल करना है, तो हम हल करने में असफल रहेंगे, लेकिन यदि आपको ReturnType: From<?X> जैसे लक्ष्य को हल करना है, तो हम संभवतः ?X लिए एक मान और अनुमान लगा लेंगे

संपादित करें: यहां, ?X कुछ अज्ञात अनुमान चर को संदर्भित करता है। आज की विशेषता प्रणाली में हार्ड-कोडित सीमा यह है कि Self प्रकार को उस विकल्प का पता लगाने के लिए कम से कम आंशिक रूप से अनुमान लगाना चाहिए।

टीएल; डीआर यह है कि Into साथ इनफ़ॉर्मिंग कठिन है, और एक अंतर्निहित तरीके से जिस तरह से विशेषता सॉल्वर कार्य करता है।

@ कृष्णशानी @ CAD97 धन्यवाद, यह मददगार है! मुझे अभी भी इस बात की चिंता है कि हम बहुत अधिक स्थिर हैं जो From पर आधारित है, हम स्थायी रूप से Into कार्यान्वयनकर्ताओं को छोड़ रहे हैं। क्या उम्मीद की जा रही है कि अंतत: यहां भी अंतःक्षिप्त हो सकता है? क्या Into सीमा में Into लागू करने का कोई कारण नहीं है, और उन सभी को कीड़े मानते हैं?

यदि इंजेक्शन पर्याप्त रूप से अच्छा है, तो इसे Into बाद में बदलने के लिए संगत होना चाहिए। सबसे बुरा जो हम तोड़ सकते हैं, वह यह है कि From का अर्थ Into

क्या यह ( Try ट्रिट) कवर ? को Into / From साथ काम करने की अनुमति देता है, जो Try लागू करने वाले प्रकारों के लिए सामान्य सीमा के साथ हैं। Result खुद)?

यानी एक क्लोजर या फंक्शन में ? जो रिटर्न करता है जैसे impl Into<Result>

(यह प्रतीत नहीं होता है कि जब मैं रात को कोशिश करता हूं?)

मैं इसे स्थिर देखने के लिए उत्सुक हूं। इस सूत्र को पढ़ने के बाद, और # 70941, मुझे लगता है कि सारांश को इस प्रकार अद्यतन किया जाना चाहिए:

1. "हल करें कि क्या पकड़ ब्लॉक" लपेटें "परिणाम मूल्य" को टिक किया जाना चाहिए, " हां के रूप में हल किया गया"

2. इन चिंता समस्याओं के बारे में नई चिंता जोड़ी गई। शायद कुछ इस तरह:

   • [] एर्गोनोमिक कठिनाइयाँ प्रकार की समस्याओं के कारण होती हैं।

ISTM कि इस अंतिम चिंता को अन्य तरीकों से संबोधित किया जा सकता है:

• स्थिरीकरण से पहले try लिए एक बीस्पोक प्रकार का सिंटैक्स सिंटैक्स जोड़ें
• यह तय करें कि https://github.com/rust-lang/rfcs/pull/803 # 23416 (टाइप अस्क्रिप्शन) इसे संबोधित करेंगे और इसे पहले स्थिर किया जाना चाहिए
• कुछ प्रकार की स्वचालित गिरावट (जैसे Result , शायद https://github.com/rust-lang/rust/issues/31436#issuecomment -614735806 में सुझाई गई है)
• भविष्य में सुधार के लिए वाक्यविन्यास / अर्थ स्थान छोड़कर try को स्थिर करने का निर्णय लें

(इनमें से कुछ विकल्प परस्पर अनन्य नहीं हैं।)

आपके ध्यान के लिए धन्यवाद और मुझे आशा है कि आपको यह संदेश मददगार लगेगा।

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

Result गिरावट में मदद मिल सकती है, लेकिन त्रुटि प्रकारों के साथ टाइप इंफ़ेक्शन समस्याओं को हल नहीं करता है: try { expr? }? (या अधिक जटिल समकक्षों में) ने प्रभावी रूप से .into() दो कॉल की हैं , जो संकलक को मध्यवर्ती प्रकार पर बहुत अधिक लचीलापन देता है।

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

हालाँकि, टाइपिंग के संबंध में, मुझे लगता है कि कार्यान्वयन की चुनौतियाँ वहाँ मुश्किल नहीं हैं। यह एक अच्छा उम्मीदवार हो सकता है कि इसमें कुछ ध्यान दें और इसे खत्म करने की कोशिश करें। मुझे याद नहीं है कि सिंटैक्स के बारे में बहुत विवाद था या ऐसा कुछ भी।

बुध पर, अगस्त 05, 2020 को 02:29:06 PM -0700 पर, निको मत्सकिस ने लिखा:

हालाँकि, टाइपिंग के संबंध में, मुझे लगता है कि कार्यान्वयन की चुनौतियाँ वहाँ मुश्किल नहीं हैं। यह एक अच्छा उम्मीदवार हो सकता है कि इसमें कुछ ध्यान दें और इसे खत्म करने की कोशिश करें। मुझे याद नहीं है कि सिंटैक्स के बारे में बहुत विवाद था या ऐसा कुछ भी।

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

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

इसके अलावा, try ब्लॉक मैक्रोज़ में उपयोगी हो सकते हैं। विशेष रूप से, मुझे आश्चर्य है कि अगर @withoutboats उत्कृष्ट फ़हलर लाइब्रेरी हमारे मैक्रो सिस्टम में कमियों से कम समस्याओं से ग्रस्त होगी, अगर यह try में प्रोक के शवों को लपेट सकती है।

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

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

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

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

@steveklabnik @ mark-im कोशिश करें कि ब्लॉक और टाइप try ब्लॉक में ही गैर-आर्थिक प्रकार की विफलता है, और सामान्यीकृत प्रकार का अस्क्रिप्शन उस समस्या को हल करने का एक तरीका हो सकता है, लेकिन चूँकि सामान्यीकृत टाइप अस्क्रिप्शन एक निकट अवधि की सुविधा या यहाँ तक कि एक निश्चित बात नहीं है, @toshttriplett (और I सहमत) नहीं चाहते कि यह सुविधा सामान्यीकृत प्रकार के प्रतिलेखन पर अवरुद्ध हो।

इसका मतलब यह भी नहीं है कि हम समस्या के समाधान के लिए सामान्यीकृत प्रकार का निर्धारण नहीं करेंगे; जांच का एक विकल्प है, "कोशिश को स्थिर करना, उम्मीद करना कि किसी दिन सामान्यीकृत टाइपिंग से यह समस्या हल हो जाएगी।" कहा गया है कि सभी प्रकार के प्रतिलेखन पर स्थिरीकरण नहीं है।

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

एक प्रश्न जो मेरे लिए होता है, उदाहरण के लिए: यह विशेष रूप से रूपांतरण लचीलापन के कारण है जो हमने Try में अनुमति दी है? मुझे पता है कि निर्णय पर चर्चा की गई है, लेकिन अगर ऐसा है तो यह नई नई जानकारी की तरह लगता है जो Try विशेषता की परिभाषा को बदलने का औचित्य साबित कर सकता है।

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