Rust: `ops::Try` (`try_trait` सुविधा) के लिए ट्रैकिंग समस्या

बाइकशेडिंग के कुछ टुकड़े:

• हम संबद्ध प्रकार कॉल करने के लिए एक विशेष प्रेरणा है Error के बजाय Err ? इसे Err कॉल करने से यह Result : दूसरे को पहले से ही Ok कहा जाता है।

• क्या हमारे पास अलग from_error और from_ok विधियों के लिए एक विशेष प्रेरणा है, एक from_result बजाय जो into_result साथ अधिक सममित होगा जो अन्य है विशेषता का आधा?

( आरएफसी से खेल के मैदान के लिंक का अद्यतन संस्करण )

@glaebhoerl

• Error बनाम Err पर https://github.com/rust-lang/rust/issues/33417#issuecomment -269108968 और https:// में TryFrom से संबंधित चर्चा की गई। github.com/rust-lang/rust/pull/40281; मुझे लगता है कि नाम इसी तरह के कारणों के लिए यहां चुना गया था।
• मेरा मानना ​​​​है कि वे अलग हैं क्योंकि उनके अलग-अलग उपयोग हैं, और मुझे उम्मीद है कि यह दुर्लभ होगा कि किसी के पास वास्तव में Result जिसे वे T:Try में बदलने की कोशिश कर रहे हैं। मैं Try::from_ok और Try::from_error को हमेशा Try::from_result(Ok( और Try::from_result(Err( कॉल करने के लिए पसंद करता हूं, और मुझे मैच लिखने के दो तरीकों को लागू करने में खुशी हो रही है। शायद ऐसा इसलिए है क्योंकि मुझे लगता है कि into_result Into<Result> रूप में नहीं है, लेकिन "क्या यह पास या असफल था?", विशिष्ट प्रकार के साथ Result एक महत्वहीन कार्यान्वयन विवरण के रूप में। (मैं सुझाव देना या फिर से खोलना नहीं चाहता "हालांकि, उत्पादन-मूल्य बनाम प्रारंभिक-वापसी के लिए एक नया प्रकार होना चाहिए।) और दस्तावेज़ीकरण के लिए, मुझे वह from_error ? बारे में बात करना पसंद है। throw ), जबकि from_ok सफलता-रैपिंग (#41414) के बारे में बात करता है, बजाय उन दोनों को एक ही तरीके से रखने के।

मुझे यकीन नहीं है कि यह इस टिप्पणी के लिए सही मंच है, अगर यह नहीं है तो कृपया मुझे पुनर्निर्देशित करें: स्माइली:। शायद यह https://github.com/rust-lang/rfcs/pull/1859 पर होना चाहिए था और मैं टिप्पणी अवधि से चूक गया; उफ़!

मैं सोच रहा था कि क्या Try विशेषता को विभाजित करने या into_result पद्धति को हटाने का कोई मामला है; मेरे लिए वर्तमान में Try कुछ हद तक लक्षणों के योग की तरह है FromResult ( from_error और from_ok ) और IntoResult ( into_result युक्त)

FromResult ? ऑपरेटर के साथ अत्यधिक एर्गोनोमिक प्रारंभिक निकास सक्षम करता है, जो मुझे लगता है कि सुविधा के लिए हत्यारा उपयोग मामला है। मुझे लगता है कि IntoResult पहले से ही प्रति-उपयोग-मामले के तरीकों के साथ या Into<Result> रूप में बड़े करीने से लागू किया जा सकता है; क्या मुझे कुछ उपयोगी उदाहरण याद आ रहे हैं?

Try विशेषता RFC के बाद , expr? रूप में desugar हो सकता है:

match expr { // Removed `Try::into_result()` here.
    Ok(v) => v,
    Err(e) => return Try::from_error(From::from(e)),
}

मैंने जिन प्रेरक उदाहरणों पर विचार किया वे हैं Future और Option ।

भविष्य

हम FromResult स्वाभाविक रूप से struct FutureResult: Future रूप में लागू कर सकते हैं:

impl<T, E> FromResult for FutureResult {
    type Ok = T;
    type Error = E;
    fn from_error(v: Self::Error) -> Self {
        future::err(v)
    }
    fn from_ok(v: Self::Ok) -> Self {
        future::ok(v)
    }
}

? लिए उचित कार्यान्वयन मानते हुए impl Future मूल्यवान फ़ंक्शन से वापस आ जाएगा जब Result::Err पर लागू किया जाता है तो मैं लिख सकता हूं:

fn async_stuff() -> impl Future<V, E> {
    let t = fetch_t();
    t.and_then(|t_val| {
        let u: Result<U, E> = calc(t_val);
        async_2(u?)
    })
}
fn fetch_t() -> impl Future<T, E> {}
fn calc(t: T) -> Result<U,E> {}

यह वही है जो मैं आज पहले लागू करने की कोशिश कर रहा था और Try इसे नाखून! लेकिन हम को लागू करने की कोशिश की है, तो वर्तमान Try के लिए Future होती है के लिए शायद कोई विहित विकल्प into_result ; यह एक बार घबराने, ब्लॉक करने या मतदान करने के लिए उपयोगी हो सकता है, लेकिन इनमें से कोई भी सार्वभौमिक रूप से उपयोगी नहीं लगता है। यदि into_result पर Try , तो मैं उपरोक्त के रूप में जल्दी निकास को लागू कर सकता हूं, और यदि मुझे Future को Result बदलने की आवश्यकता है (और तब से कोई भी Try ) मैं इसे एक उपयुक्त विधि के साथ परिवर्तित कर सकता हूं ( wait विधि को ब्लॉक करने के लिए कॉल करें, कुछ poll_once() -> Result<T,E> , आदि पर कॉल करें)।

विकल्प

Option ऐसा ही एक मामला है। हम लागू from_ok , from_err स्वाभाविक रूप में के रूप में Try विशेषता आरएफसी , और परिवर्तित कर सकते हैं Option<T> करने के लिए Result<T, Missing> बस के साथ o.ok_or(Missing) या एक सुविधा विधि ok_or_missing ।

उम्मीद है की वो मदद करदे!

मुझे इस सब के लिए शायद बहुत देर हो चुकी है, लेकिन इस सप्ताह के अंत में मेरे साथ यह हुआ कि ? उन मामलों में एक प्राकृतिक अर्थपूर्ण है जहां आप _success_ पर शॉर्ट-सर्किट करना चाहते हैं।

fn fun() -> SearchResult<Socks> {
    search_drawer()?;
    search_wardrobe()
}

लेकिन इस मामले में, Try लक्षण विधियों का नामकरण फिट नहीं है।

हालांकि, यह ? ऑपरेटर के अर्थ को विस्तृत करेगा।

रेयान के लिए try_fold प्रोटोटाइप में, मैंने खुद को Consumer::full() विधियों के लिए Try::is_error(&self) जैसा कुछ चाहा। (रेयन के पास यह है क्योंकि उपभोक्ता मूल रूप से पुश-स्टाइल इटरेटर हैं, लेकिन हम अभी भी शॉर्ट-सर्किट त्रुटियों को चाहते हैं।) इसके बजाय मुझे मध्यवर्ती मानों को Result<T::Ok, T::Err> रूप में स्टोर करना पड़ा ताकि मैं Result::is_err() कॉल कर सकूं।

से वहाँ मैं भी एक के लिए कामना की Try::from_result वापस करने के लिए प्राप्त करने के लिए T एक अंत में, लेकिन match करने के लिए मानचित्रण T::from_ok और T::from_error _भी_बुरा नहीं है।

Try विशेषता एर्गोनॉमिक्स के लिए from_result विधि प्रदान कर सकती है यदि from_ok और from_error की आवश्यकता हो। या ठीक इसके विपरीत। दिए गए उदाहरणों से मुझे दोनों की पेशकश के लिए एक मामला दिखाई देता है।

चूंकि पीआर #42275 का विलय कर दिया गया है, तो क्या इसका मतलब यह है कि इस मुद्दे को सुलझा लिया गया है?

@skade ध्यान दें कि एक प्रकार जो भी शॉर्ट-सर्किटिंग के रूप में परिभाषित कर सकता है, जैसे LoopState कुछ Iterator आंतरिक के लिए करता है। शायद यह अधिक स्वाभाविक होगा यदि Try ने सफलता या असफलता के बजाय "जारी रखने या तोड़ने" के बारे में बात की।

@cuviper जिस संस्करण की मुझे आवश्यकता थी वह या तो Ok प्रकार या Error -इन-मूल प्रकार था। मैं उम्मीद कर रहा हूं कि विनाश-और-पुनर्निर्माण एक सामान्य बात है कि यह अच्छी तरह से अनुकूलित होगा और विशेषता पर विशेष तरीकों का एक समूह की आवश्यकता नहीं होगी।

@ErichDonGubler यह एक ट्रैकिंग समस्या है, इसलिए जब तक संबंधित कोड स्थिर नहीं हो जाता, तब तक इसका समाधान नहीं होता है।

अनुभव रिपोर्ट:

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

उदाहरण:

चाक वीएम के लिए नए सॉल्वर में, मैं एक एनम रखना चाहता था जो "स्ट्रैंड" को हल करने के परिणाम को इंगित करता हो। इसकी चार संभावनाएं थीं:

enum StrandFail<T> {
    Success(T),
    NoSolution,
    QuantumExceeded,
    Cycle(Strand, Minimums),
}

मैं चाहता था ? , जब इस एनम पर लागू किया गया था, "सफलता" को खोलने के लिए, लेकिन अन्य सभी विफलताओं को ऊपर की ओर प्रचारित किया। हालांकि, Try विशेषता को लागू करने के लिए, मुझे एक प्रकार का "अवशिष्ट" प्रकार परिभाषित करना होगा जो केवल त्रुटि मामलों को समाहित करता है:

enum StrandFail {
    NoSolution,
    QuantumExceeded,
    Cycle(Strand, Minimums),
}

लेकिन एक बार जब मुझे यह प्रकार मिल गया, तो मैं StrandResult<T> एक उपनाम भी बना सकता हूं:

type StrandResult<T> = Result<T, StrandFail>;

और यही मैंने किया।

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

    /// Invoked when a strand represents an **answer**. This means
    /// that the strand has no subgoals left. There are two possibilities:
    ///
    /// - the strand may represent an answer we have already found; in
    ///   that case, we can return `StrandFail::NoSolution`, as this
    ///   strand led nowhere of interest.
    /// - the strand may represent a new answer, in which case it is
    ///   added to the table and `Ok` is returned.

ध्यान दें कि मैंने यह नहीं कहा "हम Err(StrandFail::NoSolution) लौटाते हैं। ऐसा इसलिए है क्योंकि Err बस इस कष्टप्रद आर्टिफैक्ट की तरह लगता है जिसे मुझे जोड़ना है।

(दूसरी ओर, वर्तमान परिभाषा पाठकों को यह जानने में मदद करेगी कि ? का व्यवहार Try impl से परामर्श किए बिना क्या है।)

मुझे लगता है कि यह परिणाम आश्चर्यजनक नहीं है: वर्तमान Try impl आपको ? उन चीजों पर करने के लिए मजबूर करता है जो Result लिए आइसोमॉर्फिक हैं। यह एकरूपता कोई दुर्घटना नहीं है, लेकिन परिणामस्वरूप, यह उन चीजों के साथ ? का उपयोग करना कष्टप्रद बनाता है जो मूल रूप से "सिर्फ Result " नहीं हैं। (उस बात के लिए, यह मूल रूप से एक ही समस्या है कि को जन्म देता है है NoneError - कृत्रिम रूप से करने की जरूरत एक प्रकार एक के "विफलता" का प्रतिनिधित्व करने को परिभाषित Option ।)

मैं यह भी नोट करूंगा कि, StrandFail के मामले में, मैं विशेष रूप से From::from रूपांतरण नहीं चाहता जो सामान्य परिणाम प्राप्त करता है, हालांकि यह मुझे नुकसान नहीं पहुंचा रहा है।

क्या संबंधित Try::Error प्रकार कभी भी सीधे उपयोगकर्ता द्वारा उपयोग किया जाता है? या यह सिर्फ ? की desugaring के हिस्से के रूप में आवश्यक है? यदि उत्तरार्द्ध, मुझे इसे "संरचनात्मक रूप से" परिभाषित करने के साथ कोई वास्तविक समस्या नहीं दिखती है - type Error = Option<Option<(Strand, Minimums)>> या जो भी हो। ( enum परिभाषा के "विफलता आधे" के संरचनात्मक समकक्ष को समझने के लिए बहुत अच्छा नहीं है, लेकिन पूरे सार्वजनिक-सामना करने वाले एपीआई को फिर से शुरू करने से कम परेशान लगता है।)

मैं भी पीछा नहीं करता। मैंने एक प्रकार के लिए प्रयास को सफलतापूर्वक कार्यान्वित किया है जिसमें आंतरिक त्रुटि प्रतिनिधित्व था और यह Ok और Error एक ही प्रकार के होने के कारण स्वाभाविक लगा। आप यहां कार्यान्वयन देख सकते हैं: https://github.com/kevincox/ecl/blob/8ca7ad2bc4775c5cfc8eb9f4309b2666e5163e02/src/lib.rs#L298 -L308

वास्तव में ऐसा लगता है कि इस काम को करने के लिए काफी सरल पैटर्न है।

impl std::ops::Try for Value {
    type Ok = Self;
    type Error = Self;

    fn from_ok(v: Self::Ok) -> Self { v }
    fn from_error(v: Self::Error) -> Self { v }
    fn into_result(self) -> Result<Self::Ok, Self::Error> {
        if self.is_ok() { Ok(val) } else { Err(val) }
    }
}

यदि आप सफलता को खोलना चाहते हैं तो कुछ इस तरह काम करना चाहिए:

impl std::ops::Try for StrandFail<T> {
    type Ok = T;
    type Error = Self;

    fn from_ok(v: Self::Ok) -> Self { StrandFail::Success(v) }
    fn from_error(v: Self::Error) -> Self { v }
    fn into_result(self) -> Result<Self::Ok, Self::Error> {
        match self {
            StrandFail::Success(v) => Ok(v),
            other => Err(other),
        }
    }
}

एक संरचनात्मक प्रकार को परिभाषित करना संभव है लेकिन बहुत कष्टप्रद लगता है। मैं सहमत हूं कि मैं Self उपयोग कर सकता हूं। यह मेरे लिए थोड़ा निराला लगता है कि फिर आप ? का उपयोग StrandResult से Result<_, StrandResult> आदि में बदलने के लिए कर सकते हैं।

शानदार अनुभव रिपोर्ट, @nikomatsakis! मैं Try (दूसरी दिशा से) से भी असंतुष्ट हूं।

TL/DR : मुझे लगता है कि FoldWhile को यह अधिकार मिल गया है, और हमें Break -vs- Continue बारे में बात करने के बजाय ? व्याख्या पर डबल-डाउन करना चाहिए। इसे त्रुटियों के संदर्भ में।

लंबा:

मैं "त्रुटि" की तुलना में "सफलता" के करीब कुछ के लिए Err का उपयोग करता रहता हूं क्योंकि ? इतना सुविधाजनक है।

• try_fold का उपयोग करते समय position (और अन्य इटरेटर विधियों का एक गुच्छा) Result का उपयोग करते समय ऊपर था (मेरे दिमाग को find पसंद नहीं था Err ) खोजने के लिए कि मैंने इसके बजाय Break और Continue वेरिएंट के साथ अपना खुद का

• itertools में tree_fold1 लिखते समय , मैं एक अजीब match साथ समाप्त हुआ None एक से "त्रुटि" है Iterator::next() , लेकिन एक ही समय में यह एक से "सफलता" fold , जब से तुम अंत करने के लिए प्राप्त करने की आवश्यकता किया गया। और अंतिम स्थिति के प्रचार से निपटने के लिए ? (ठीक है, उस कोड में try! का उपयोग करना बहुत सुविधाजनक है

तो अगर और कुछ नहीं, तो मुझे लगता है कि मैंने Try लिए जो विवरण लिखा है वह गलत है, और "सफलता/विफलता द्वंद्ववाद" के बारे में बात नहीं करनी चाहिए, बल्कि "त्रुटियों" से दूर होना चाहिए।

दूसरी बात जो मैं सोच रहा था, वह यह है कि हमें Try लिए कुछ थोड़े-से-पागल अर्थों पर विचार करना चाहिए। उदाहरण के लिए, Ordering: Try<Ok = (), Error = GreaterOrLess> , "कोशिश कार्यों" के साथ संयुक्त रूप से cmp लिए struct Foo<T, U> { a: T, b: U } दे सकता है

fn cmp(&self, other: &self) -> Ordering try {
    self.a.cmp(&other.a)?;
    self.b.cmp(&other.b)?;
}

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

मैं यह भी नोट करता हूं कि यह एक और उदाहरण है जहां "त्रुटि-रूपांतरण" सहायक नहीं है। मैंने इसे "मैं चाहता हूं? लेकिन यह कोई त्रुटि नहीं है" उदाहरणों में इसका उपयोग कभी नहीं किया। और यह निश्चित रूप से अनुमान उदासी पैदा करने के लिए जाना जाता है, इसलिए मुझे आश्चर्य है कि यह एक ऐसी चीज है जो केवल परिणाम तक सीमित होनी चाहिए (या संभावित रूप से .map_err(Into::into) पक्ष में हटा दी गई है, लेकिन यह शायद संभव नहीं है)।

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

संपादित करें 2: यह ऊपर https://github.com/rust-lang/rust/issues/42327#issuecomment -318923393 के विपरीत नहीं है

संपादित करें 3: ऐसा लगता है कि https://github.com/rust-lang/rfcs/pull/1859#issuecomment -273985250 में एक Continue संस्करण भी प्रस्तावित किया गया था।

मेरे दो सेंट:

मुझे विशेषता को दो लक्षणों में विभाजित करने का @fluffysquirrels का सुझाव पसंद है। एक परिणाम में कनवर्ट करने के लिए, और दूसरा परिणाम से कनवर्ट करने के लिए। लेकिन मुझे लगता है कि हमें desugaring के हिस्से के रूप में into_result या समकक्ष रखना चाहिए। और मुझे लगता है कि इस बिंदु पर हमें Option का उपयोग करना होगा क्योंकि Try स्थिर हो गया है।

मुझे उन नामों का उपयोग करने का @scottmcm का विचार भी पसंद है जो त्रुटि/ठीक के बजाय ब्रेक/जारी रखने का सुझाव देते हैं।

यहां विशिष्ट कोड डालने के लिए, मुझे यह पसंद है कि यह कैसे पढ़ता है:

https://github.com/rust-lang/rust/blob/ab8b961677ac5c74762dea955aa0ff4d7fe4915/src/libcore/iter/iterator.rs#L1738 -L1746

यह निश्चित रूप से सीधे लूप जितना अच्छा नहीं है, लेकिन "कोशिश विधियों" के साथ यह करीब होगा:

self.try_for_each(move |x| try { 
    if predicate(&x) { return LoopState::Break(x) } 
}).break_value() 

तुलना के लिए, मुझे "त्रुटि शब्दावली" संस्करण वास्तव में भ्रामक लगता है:

self.try_for_each(move |x| { 
    if predicate(&x) { Err(x) } 
    else { Ok(()) } 
}).err() 

क्या हम किसी भी त्रुटि के लिए प्रदर्शन लागू कर सकते हैं? यह विफलता क्रेट को स्वचालित रूप से From<NoneError> for failure::Error प्राप्त करने की अनुमति देगा। देखें https://github.com/rust-lang-nursery/failure/issues/61
यह एक 3 लाइन परिवर्तन होना चाहिए, लेकिन मैं आरएफसी और इस तरह की प्रक्रिया के बारे में निश्चित नहीं हूं।

@cowang4 मैं अभी परिणाम-और-विकल्प के किसी और मिश्रण को सक्षम करने से बचने की कोशिश करना चाहता हूं, क्योंकि हमारे विकल्प वहां खुले रखने के लिए प्रकार अस्थिर है। मुझे आश्चर्य नहीं होगा अगर हम Try के डिज़ाइन को बदल दें और desugar को किसी ऐसी चीज़ में बदल दें जिसकी आवश्यकता नहीं है NoneError ...

@scottmcm ठीक है। तुम्हारी बात सही है। जब लाइब्रेरी फ़ंक्शन कोई नहीं लौटाता है तो मुझे अंततः एर लौटने के पैटर्न को चीनी के लिए एक साफ तरीका चाहिए। हो सकता है कि आप Try अलावा किसी अन्य के बारे में जानते हों? उदाहरण:

fn work_with_optional_types(pb: &PathBuf) -> Result<MyStruct, Error> {
    if let Some(filestem) = pb.file_stem() {
        if let Some(filestr) = filestem.to_str() {
            return Ok(MyStruct {
                filename: filestr.to_string()
            });
        }
     }
    Err(_)
}

एक बार जब मुझे यह प्रायोगिक विशेषता और failure टोकरा मिल गया, तो मैं स्वाभाविक रूप से इस ओर आकर्षित हुआ:

use failure::Error;
fn work_with_optional_types(pb: &PathBuf) -> Result<MyStruct, Error> {
    Ok({
        title: pb.file_stem?.to_str()?.to_string()
    })
}

जैसा कि मैंने पहले उल्लेख किया था, impl Display for NoneError की कमी को छोड़कर, कौन सा _लगभग_ काम करता है।
लेकिन, अगर यह वह सिंटैक्स नहीं है जिसके साथ हम जाना चाहते हैं, तो शायद कोई अन्य फ़ंक्शन / मैक्रो हो सकता है जो पैटर्न को सरल करता है:

if option.is_none() {
    return Err(_);
}

@ cowang4 मेरा मानना ​​​​है कि यदि आप From<NoneError> failure::Error लिए लागू करते हैं, तो यह काम करेगा, जो आपके अपने प्रकार का उपयोग करता है जो Display ।

हालांकि, opt.ok_or(_)? का उपयोग करना शायद बेहतर अभ्यास है ताकि आप स्पष्ट रूप से कह सकें कि यदि विकल्प कोई नहीं है तो त्रुटि क्या होनी चाहिए। उदाहरण के लिए, आपके उदाहरण में, यदि pb.file_stem कोई नहीं है तो आप एक अलग त्रुटि चाहते हैं, यदि to_str() कोई नहीं देता है।

@tmccombs मैंने अपना त्रुटि प्रकार बनाने का प्रयास किया, लेकिन मैंने इसे गलत किया होगा। यह इस प्रकार था:

#[macro_use] extern crate failure_derive;

#[derive(Fail, Debug)]
#[fail(display = "An error occurred.")]
struct SiteError;

impl From<std::option::NoneError> for SiteError {
    fn from(_err: std::option::NoneError) -> Self {
        SiteError
    }
}

fn build_piece(cur_dir: &PathBuf, piece: &PathBuf) -> Result<Piece, SiteError> {
    let title: String = piece
        .file_stem()?
        .to_str()?
        .to_string();
    Ok(Piece {
        title: title,
        url: piece
            .strip_prefix(cur_dir)?
            .to_str()
            .ok_or(err_msg("tostr"))?
            .to_string(),
    })
}

और फिर मैंने अपने त्रुटि प्रकार का उपयोग करने की कोशिश की ...

error[E0277]: the trait bound `SiteError: std::convert::From<std::path::StripPrefixError>` is not satisfied
   --> src/main.rs:195:14
    |
195 |           url: piece
    |  ______________^
196 | |             .strip_prefix(cur_dir)?
    | |___________________________________^ the trait `std::convert::From<std::path::StripPrefixError>` is not implemented for `SiteError`
    |
    = help: the following implementations were found:
              <SiteError as std::convert::From<std::option::NoneError>>
    = note: required by `std::convert::From::from`

error[E0277]: the trait bound `SiteError: std::convert::From<failure::Error>` is not satisfied
   --> src/main.rs:195:14
    |
195 |           url: piece
    |  ______________^
196 | |             .strip_prefix(cur_dir)?
197 | |             .to_str()
198 | |             .ok_or(err_msg("tostr"))?
    | |_____________________________________^ the trait `std::convert::From<failure::Error>` is not implemented for `SiteError`
    |
    = help: the following implementations were found:
              <SiteError as std::convert::From<std::option::NoneError>>
    = note: required by `std::convert::From::from`

ठीक है, मुझे अभी एहसास हुआ कि यह जानना चाहता है कि अन्य त्रुटि प्रकारों से मेरी त्रुटि में कैसे परिवर्तित किया जाए, जिसे मैं सामान्य रूप से लिख सकता हूं:

impl<E: failure::Fail> From<E> for SiteError {
    fn from(_err: E) -> Self {
        SiteError
    }
}

नहीं...

error[E0119]: conflicting implementations of trait `std::convert::From<SiteError>` for type `SiteError`:
   --> src/main.rs:183:1
    |
183 | impl<E: failure::Fail> From<E> for SiteError {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: conflicting implementation in crate `core`:
            - impl<T> std::convert::From<T> for T;

ठीक है, std::error::Error बारे में क्या?

impl<E: std::error::Error> From<E> for SiteError {
    fn from(_err: E) -> Self {
        SiteError
    }
}

यह भी काम नहीं करता। आंशिक रूप से क्योंकि यह मेरे From<NoneError> साथ विरोध करता है

error[E0119]: conflicting implementations of trait `std::convert::From<std::option::NoneError>` for type `SiteError`:
   --> src/main.rs:181:1
    |
175 | impl From<std::option::NoneError> for SiteError {
    | ----------------------------------------------- first implementation here
...
181 | impl<E: std::error::Error> From<E> for SiteError {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `SiteError`
    |
    = note: upstream crates may add new impl of trait `std::error::Error` for type `std::option::NoneError` in future versions

जो अजीब है क्योंकि मैंने सोचा था कि NoneError ने std::error::Error लागू नहीं किया। जब मैं अपने गैर-सामान्य impl From<NoneError> टिप्पणी करता हूं तो मुझे मिलता है:

error[E0277]: the trait bound `std::option::NoneError: std::error::Error` is not satisfied
   --> src/main.rs:189:25
    |
189 |       let title: String = piece
    |  _________________________^
190 | |         .file_stem()?
    | |_____________________^ the trait `std::error::Error` is not implemented for `std::option::NoneError`
    |
    = note: required because of the requirements on the impl of `std::convert::From<std::option::NoneError>` for `SiteError`
    = note: required by `std::convert::From::from`

क्या मुझे सभी From s मैन्युअल रूप से लिखने होंगे। मैं हालांकि कि विफलता टोकरा उन्हें प्राप्त करने वाला था?

शायद मुझे option.ok_or() साथ रहना चाहिए

क्या मुझे सभी Froms को मैन्युअल रूप से लिखना है। मैं हालांकि कि विफलता टोकरा उन्हें प्राप्त करने वाला था?

मुझे नहीं लगता कि विफलता टोकरा ऐसा करता है। लेकिन मुझसे गलती हो सकती है।

ठीक है, इसलिए मैंने विफलता टोकरा की फिर से जांच की, और अगर मैं दस्तावेज़ीकरण और विभिन्न संस्करणों को सही पढ़ रहा हूं, तो इसे हमेशा failure::Error को आपके Result s में त्रुटि प्रकार के रूप में उपयोग करने के लिए डिज़ाइन किया गया है, यहाँ देखें । और, यह अधिकांश त्रुटि प्रकारों के लिए एक कंबल impl Fail विशेषता को लागू करता है:

impl<E: StdError + Send + Sync + 'static> Fail for E {}

https://github.com/rust-lang-nursery/failure/blob/master/failure-1.X/src/lib.rs#L218

और फिर एक impl From ताकि यह Try / ? अन्य त्रुटियों (जैसे एसटीडी से) को व्यापक failure::Error प्रकार में बदल सके।
rust impl<F: Fail> From<F> for ErrorImpl
https://github.com/rust-lang-nursery/failure/blob/d60e750fa0165e9c5779454f47a6ce5b3aa426a3/failure-1.X/src/error/error_impl.rs#L16

लेकिन, यह सिर्फ इतना है कि चूंकि इस जंग के मुद्दे से संबंधित त्रुटि, NoneError , प्रयोगात्मक है, इसे अभी तक स्वचालित रूप से परिवर्तित नहीं किया जा सकता है, क्योंकि यह Display विशेषता को लागू नहीं करता है। और, हम इसे नहीं चाहते, क्योंकि यह Option s और Result s के बीच की रेखा को धुंधला करता है। यह सब शायद फिर से काम करेगा और अंततः हल हो जाएगा, लेकिन अभी के लिए, मैं उन डी-शक्कर तकनीकों से चिपके रहूंगा जो मैंने सीखी हैं।

मदद करने के लिए आप सभी का धन्यवाद। मैं धीरे-धीरे जंग सीख रहा हूँ! :मुस्कुराओ:

मैं उन डी-शक्कर तकनीकों से चिपके रहूंगा जो मैंने सीखी हैं।

:+1: ईमानदारी से, मुझे लगता है कि .ok_or(...)? जाने का रास्ता बना रहेगा (या निश्चित रूप से .ok_or_else(|| ...)? )। भले ही NoneError _had_ एक Display impl, यह क्या कहेगा? "कुछ नहीं था"? यह कोई बड़ी गलती नहीं है...

किसी ठोस प्रस्ताव के करीब जाने का प्रयास...

मुझे TrySuccess विकल्प पसंद आने लगा है। दिलचस्प बात यह है कि मुझे लगता है कि _nobody_, जिसमें मैं खुद शामिल था, ने उसे मूल रूप से पसंद किया - यह RFC के अंतिम संस्करण में भी नहीं है। लेकिन शुक्र है कि यह इतिहास में जीवित है: https://github.com/rust-lang/rfcs/blob/f89568b1fe5db4d01c4668e0d334d4a5abb023d8/text/0000-try-trait.md#using -an-संबद्ध-प्रकार-फॉर-द-सफलता -मूल्य

मुझे ऐसा लगता है कि इस पर सबसे बड़ी आपत्ति उचित शिकायत थी कि सिर्फ एक संबद्ध प्रकार ( trait TrySuccess { type Success; } ) के लिए एक संपूर्ण मूल विशेषता अधिक थी। लेकिन catch try ब्लॉक बैक (https://github.com/rust-lang/rust/issues/41414#issuecomment-373985777) ओके-रैपिंग करने के लिए (जैसा कि RFC में है) , अचानक इसका एक सीधा और महत्वपूर्ण उपयोग होता है: यह वह विशेषता है जो उस रैपिंग को नियंत्रित करती है। " ? साथ मिलकर हमेशा एक ही प्रकार का उत्पादन करना चाहिए" लक्ष्य जो मुझे लगता है कि आम तौर पर वांछित था, विशेषता बेहतर वजन रखती है। काकभगौड़ा:

trait TryContinue {
    type Continue;
    fn from_continue(_: Self::Continue) -> Self;
}

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

संपादित करें: बाइकशेड के लिए, "वापसी" एक अच्छा शब्द हो सकता है, क्योंकि ऐसा तब होता है जब आप return try विधि (उर्फ ओके-रैपिंग) से return । return इसके लिए मोनाड ऑपरेटर का नाम भी है, iiuc...

संपादित करें 2: अन्य लक्षणों/विधि पर मेरे विचार अभी तक स्थिर नहीं हुए हैं, @tmccombs।

@scottmcm बस स्पष्ट होने के लिए, या आप निम्नलिखित दो लक्षणों का सुझाव दे रहे हैं?

trait TryContinue {
  type Continue;
  fn from_continue(_: Self::Continue) -> Self;
}

trait Try<E>: TryContinue {
  fn try(self) -> Result<Self::Continue, E>
}

और x? को डिसुगर करना कुछ इस तरह दिखेगा:

x.try() match {
    Ok(c) => c,
   Err(e) => throw e // throw here is just a placeholder for either returning or breaking out of a try block
}

और try { ...; expr} कुछ इस तरह से desugar होगा:

{ 
    ...
    TryContinue::from_continue(expr);
}

@scottmcm मुझे भी ठीक-रैपिंग पर विचार करते समय वह संस्करण अधिक आकर्षक लगता है =)

अगली विशेषता पर जारी रखते हुए, मुझे लगता है कि ? यह बन जाता है (मॉड्यूलो बड़े पैमाने पर बाइकिंग):

trait Try<Other: TryContinue = Self>: TryContinue + Sized {
    fn check(x: Other) -> ControlFlow<Other::Continue, Self>;
}

enum ControlFlow<C, B> {
    Continue(C),
    Break(B),
}

मिश्रित औचित्य:

• इसके तर्क प्रकार के लिए TryContinue आवश्यकता होती है ताकि x? अभिव्यक्ति का प्रकार हमेशा समान हो
• इस चूक के लिए प्रकार पैरामीटर Self की तरह साधारण मामलों के लिए try_fold कि निरीक्षण और एक ही प्रकार के लौटने के लिए, तो बस के साथ ठीक कर रहे हैं T: Try ।
• यह विशेषता TryContinue तक फैली हुई है क्योंकि यदि रिटर्न प्रकार के रूप में उपयोग किया जाने वाला प्रकार अपने शरीर में ? अनुमति देता है, तो उसे ओके-रैपिंग का भी समर्थन करना चाहिए।
• नया एनम परिणाम के लिए आइसोमॉर्फिक है, लेकिन ऊपर चर्चा की गई "त्रुटियों" के संदर्भ में बात करने से बचता है, और परिणामस्वरूप मुझे लगता है कि यह प्रत्येक प्रकार के लिए एक बहुत स्पष्ट अर्थ प्रदान करता है।
• ? का तर्क सामान्य प्रकार है, ताकि TryContinue , यह "किसी चीज़ से Self उत्पन्न करता है"

try{} / ? और Option , Result , और Ordering लिए मैक्रो सहित पूर्ण प्रूफ-ऑफ-कॉन्सेप्ट डेमो: https ://play.rust-lang.org/?gist=18663b73b6f35870d20fd172643a4f96&version=stable (धन्यवाद @nikomatsakis एक साल पहले इनमें से मूल बनाने

डाउनसाइड्स:

• अभी भी Result में प्रेत प्रकार पैरामीटर हैं जो मुझे वास्तव में पसंद नहीं हैं
  
  
  
  • लेकिन हो सकता है कि Ordering impl में अतिरिक्त LessOrGreater प्रकार की आवश्यकता न होने के लिए यह एक अच्छा ट्रेडऑफ़ है।
  
  
  • और इम्प्लस में प्रेत प्रकार पैरामीटर वैसे भी प्रकारों की तुलना में कम icky हैं
  
  
• एक सुसंगत From परिवर्तन नहीं देता
  
  
  
  • लेकिन यह अच्छा हो सकता है, क्योंकि StrandResult ने वैसे भी परवाह नहीं की, SearchResult जैसी किसी चीज़ के लिए यह अजीब होगा क्योंकि ब्रेक पथ सफलता पथ है, और यह अंत में अनुमान लगाने में मदद कर सकता है नेस्टेड- ? वैसे भी मामले।
  
  
• यह स्पष्ट नहीं है कि throw सिंटैक्स क्या होगा
  
  
  
  • के विवरण खो देता है कौन सा ? के रूप में Ok(x) => x, Err(r) => throw e.into() है कि मैं वास्तव में पसंद
  
  
  • लेकिन throw; को None ( impl<T> Throw<()> for Option<T> जैसे कुछ के माध्यम से) का उत्पादन करने का तरीका भी दे सकता है, जो कि throw NoneError; से बेहतर है
  
  
  • और इसे अलग करना वैसे भी अच्छा हो सकता है, क्योंकि throw LessOrGreater::Less _really_ मूर्खतापूर्ण होता।
  
  

संपादित करें: पिंग @glaebhoerl , जिसकी राय मैं इस पर RFC 1859 में एक बड़े भागीदार के रूप में चाहूंगा।

2 संपादित करें: https://github.com/rust-lang/rfcs/pull/1859#issuecomment -287402652 के इस कथन के लिए cc @colin-kiegel भी:

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

मुझे वह प्रस्ताव बहुत पसंद है।

यह स्पष्ट नहीं है कि थ्रो सिंटैक्स क्या होगा

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

@tmccombs

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

हालांकि यह समान सामान के साथ आता है, मुझे संदेह है कि "उठाना" बेहतर फिट है:

फेंकना (v): किसी स्थान, स्थिति, स्थिति आदि में जाने या आने का कारण, जैसे कि फेंकना:

उठाना (v): एक उच्च पद पर जाने के लिए; उठाना; तरक्की

? के तर्क के साथ "raise" को संयोजित करने का एक तरीका हो सकता है, यह देखते हुए कि raise का अर्थ "एकत्र" भी हो सकता है। कुछ इस तरह: Ok(v) => v, Err(e) => raise From::from(e) , जहां raise मिलान किए गए पैटर्न की नकल करता है (उदाहरण के लिए एक पैटर्न Err(e) दिया गया है यह ControlFlow::Break(Err(...)) लिए वाक्य रचनात्मक जादू है)।

मुझे संदेह है कि "उठाना" एक बेहतर फिट है

अच्छी बात

@scottmcm

यह स्पष्ट नहीं है कि थ्रो सिंटैक्स क्या होगा

क्या कोई कारण है कि हमारे पास from_err(value: Other) ?

अद्यतन: शायद मैं वास्तव में Other की भूमिका के बारे में उलझन में हूं। मुझे इस विशेषता का थोड़ा और अध्ययन करना है। =)

@nikomatsakis

क्या कोई कारण है कि हमारे पास from_err(value: Other) ?

खैर, Other एक संपूर्ण ? -सक्षम प्रकार है (जैसे Result ), इसलिए मैं नहीं चाहता कि throw Ok(4) काम करे। (और कृत्रिम त्रुटि प्रकार की शुरूआत से बचने के लिए इसे पूरी तरह से अलग होने की आवश्यकता है।) उदाहरण के लिए, मुझे लगता है कि हमारा वर्तमान विकल्प-परिणाम इंटरऑप इसके बराबर होगा (और उलटा):

impl<T, F, U> Try<Option<U>> for Result<T, F>
   where F: From<NoneError>
{
    fn check(x: Option<U>) -> ControlFlow<U, Self> {
        match x {
            Some(x) => ControlFlow::Continue(x),
            None => ControlFlow::Break(Err(From::from(NoneError))),
        }
    }
}

throw लिए मेरा वर्तमान झुकाव इसके लिए होगा:

trait TryBreak<T> : TryContinue { from_break(_: T) -> Self }

साथ

throw $expr  ==>  break 'closest_catch TryBreak::from_break($expr)

• TryContinue बढ़ाता है ताकि ओके-रैपिंग उस विधि के रिटर्न प्रकार के लिए भी उपलब्ध हो जिसमें इसका उपयोग किया जाता है
• एक संबद्ध प्रकार नहीं है, TryBreak<TryFromIntError> यदि आप चाहें तो एक प्रकार के लिए TryBreak<io::Error> दोनों को लागू कर सकते हैं।
  
  
  
  • और impl<T> TryBreak<()> for Option<T> सिर्फ throw; impl<T> TryBreak<()> for Option<T> को सक्षम करने के लिए एक तरह से प्रशंसनीय लगता है कि एक संबद्ध त्रुटि प्रकार () नहीं था।
  
  
  • impl<T> TryBreak<!> for T भी अच्छा होगा, लेकिन शायद असंगत है।
  
  

(इसके अलावा: ये विशेषता और विधि नाम भयानक हैं; कृपया मदद करें !)

यहां उठाए गए अन्य मुद्दों के बारे में मेरे विचार अभी तक आसानी से स्पष्ट रूप में नहीं आए हैं, लेकिन From::from() desugaring के आसपास प्रकार की अनुमान समस्याओं के संबंध में (मुझे याद नहीं है कि क्या इस पर हाल ही में कहीं और चर्चा की गई थी) , या केवल यहाँ?):

सहज ज्ञान (हास्केल अनुभव से) कि "इस तरह झूठ प्रकार अनुमान अस्पष्टता" एक (हालांकि मुख्य नहीं) कारणों में से एक था कि मैं मूल आरएफसी के हिस्से के रूप में From रूपांतरण क्यों नहीं चाहता था। अब जब यह केक में बेक हो गया है, हालांकि, मुझे आश्चर्य है कि क्या हम उस केक को रखने की कोशिश नहीं कर सकते हैं और इसे 'सिर्फ' टाइप करके इसके लिए एक विशेष डिफ़ॉल्ट नियम जोड़कर खा सकते हैं?

यही है, मुझे लगता है: जब भी हम एक From::from() [वैकल्पिक रूप से: एक जो मैन्युअल रूप से लिखे जाने के बजाय ? desugaring द्वारा डाला गया था], और हम वास्तव में दो प्रकारों में से एक को जानते हैं (इनपुट बनाम आउटपुट), जबकि दूसरा अस्पष्ट है, हम डिफ़ॉल्ट रूप से दूसरे को एक जैसा ही मानते हैं। दूसरे शब्दों में, मुझे लगता है, जब यह स्पष्ट नहीं है कि किस impl From का उपयोग करना है, तो हम डिफ़ॉल्ट रूप से impl<T> From<T> for T । यह, मुझे लगता है, मूल रूप से हमेशा वही होता है जो आप वास्तव में चाहते हैं? यह शायद थोड़ा तदर्थ है, लेकिन अगर यह काम करता है, तो लाभ IMHO की लागत के लायक लगते हैं।

(मैंने यह भी सोचा था कि From पहले से ही एक लैंग आइटम था, ठीक ? डिसुगरिंग के कारण, लेकिन ऐसा प्रतीत नहीं होता है? किसी भी मामले में, यह पहले से ही कुछ मायनों में उस कारण से विशेष है ।)

@scottmcm के प्रस्ताव में, From::from() desugaring का _not_ हिस्सा है, बल्कि यह Try लिए Result के कार्यान्वयन में है।

@tmccombs मैं उनके प्रस्ताव में संशोधन का प्रस्ताव नहीं दे रहा था।

try{} RFC (https://github.com/rust-lang/rfcs/pull/2388) try ब्लॉक पर चर्चा कर रहा है जहां कोई परिणाम की परवाह नहीं करता है। ऐसा लगता है कि यह विकल्प शालीनता से अच्छी तरह से संभालता है, क्योंकि यह पूरी तरह से त्रुटि प्रकारों को अनदेखा करना चुन सकता है यदि वह चाहें, अनुमति देता है

let IgnoreErrors = try {
    error()?;
    none()?;
};

पहले के समान लक्षणों का उपयोग करते हुए प्रूफ-ऑफ-कॉन्सेप्ट कार्यान्वयन: https://play.rust-lang.org/?gist=e0f6677632e0a9941ed1a67ca9ae9c98&version=stable

मुझे लगता है कि वहां कुछ दिलचस्प संभावनाएं हैं, खासकर जब से एक कस्टम कार्यान्वयन कह सकता है, केवल परिणाम ले सकता है और E: Debug बाध्य कर सकता है, इसलिए यह स्वचालित रूप से होने वाली किसी भी त्रुटि को लॉग करता है। या एक संस्करण के लिए एक वापसी प्रकार के रूप में विशेष रूप से इरादा बनाया जा सकता है main के साथ संयोजन के रूप में Termination है कि "सिर्फ काम करता है" आप का उपयोग करने देने ? जटिल प्रकार हस्ताक्षर के बिना (https ://github.com/rust-lang/rfcs/issues/2367)।

मेरे पास इसी तरह के मुद्दे हैं जो @nikomatsakis द्वारा Try विशेषता के मौजूदा संस्करण का उपयोग करके प्रमाणित किए गए हैं । विशिष्ट मुद्दों के लिए, https://github.com/SergioBenitez/Rocket/issues/597#issuecomment -381533108 देखें।

@scottmcm द्वारा प्रस्तावित विशेषता परिभाषाएँ इन मुद्दों को हल करती हैं। हालाँकि, वे आवश्यकता से अधिक जटिल प्रतीत होते हैं। मैंने उन्हें फिर से लागू करने में एक दरार ली और निम्नलिखित के साथ आया:

#[derive(Debug, Copy, Clone)]
enum ControlFlow<C, B> {
    Continue(C),
    Break(B),
}

// Used by `try { }` expansions.
trait FromTry: Try {
    fn from_try(value: Self::Continue) -> Self;
}

// Used by `?`.
trait Try<T = Self>: Sized {
    type Continue;
    fn check(x: T) -> ControlFlow<Self::Continue, Self>;
}

मुख्य परिवर्तन यह है कि Continue संबद्ध प्रकार Try विशेषता पर है जो FromTry (पहले TryContinue ) के विपरीत है। परिभाषाओं को सरल बनाने के अलावा, इस लाभ यह है कि है Try के स्वतंत्र लागू किया जा सकता FromTry , जो मैं अधिक आम का मानना है, और है कि लागू करने FromTry सरल है एक बार Try लागू किया गया है। (नोट: यदि यह वांछित है कि Try और FromTry को एक साथ लागू किया जाए, तो हम केवल from_try पद्धति को Try स्थानांतरित कर सकते हैं)

के लिए कार्यान्वयन के साथ पूरा खेल का मैदान देखें Result और Option के रूप में अच्छी तरह से रॉकेट के रूप में Outcome पर इस खेल का मैदान ।

रिपोर्ट के लिए धन्यवाद, @SergioBenitez! यह कार्यान्वयन RFC 1859 में मूल विशेषता प्रस्ताव के वैकल्पिक संस्करण "फ्लिप द टाइप पैरामीटर" से मेल खाता है: https://github.com/rust-lang/rfcs/blob/f89568b1fe5db4d01c4668e0d334d4a5abb023d8/text/0000-try-trait.md#unresolved -प्रशन

सबसे बड़ी चीज जो खोती है वह संपत्ति है जो typeof(x?) केवल typeof(x) पर निर्भर करती है। उस संपत्ति की कमी मूल के साथ चिंताओं में से एक थी ("मुझे इन पंक्तियों के साथ कोड में पठनीयता के बारे में थोड़ी चिंता है" https://github.com/rust-lang/rfcs/pull/1859#issuecomment-279187967) और एक फायदा अंतिम न्यूनीकरण प्रस्ताव ("किसी भी प्रकार के टी के लिए, ? ठीक एक प्रकार का ठीक/त्रुटि मान उत्पन्न कर सकता है" https://github.com/rust-lang/rfcs/pull/1859#issuecomment-283104310)। बेशक, ऐसे तर्क भी थे जो कहते थे कि संपत्ति अनावश्यक या बहुत अधिक प्रतिबंधात्मक है, लेकिन अंतिम सारांश में इससे पहले कि FCP यह अभी भी एक लाभ के रूप में था (https://github.com/rust-lang/rfcs/pull/1859#issuecomment -295878466)।

परिभाषाओं को सरल बनाने के अलावा, इसका यह फायदा है कि Try को FromTry स्वतंत्र रूप से लागू किया जा सकता है, जिसे मैं अधिक सामान्य मानता हूं

निश्चित रूप से आज from_ok कम आम है, क्योंकि Try और do catch अस्थिर हैं। और भले ही do catch स्थिर थे, मैं सहमत हूं कि इसका उपयोग कुल मिलाकर ? से कम किया जाएगा (चूंकि ऐसे अधिकांश ब्लॉक में एकाधिक ? s होते हैं)।

विशेषता और इसके संचालन के परिप्रेक्ष्य से, हालांकि, मुझे लगता है कि "वाहक प्रकार में एक 'चलते रहें' मूल्य लपेटें" ? का एक बिल्कुल आवश्यक हिस्सा है। आज शायद ही कोई उस विशेषता के माध्यम से जाता है - इसके बजाय केवल Ok(...) या Some(...) उपयोग करना - लेकिन यह सामान्य उपयोग के लिए महत्वपूर्ण है। उदाहरण के लिए, try_fold :

https://github.com/rust-lang/rust/blob/8728c7a726f3e8854f5a80b474d1a8bacab10304/src/libcore/iter/iterator.rs#L1478 -L1482

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

@Centril ने पहले भी बताया है कि "कैरियर में एक स्केलर लपेटें" सैद्धांतिक रूप से एक सरल निर्माण भी है। उदाहरण के लिए, हास्केल इसे Pointed टाइपक्लास कहते हैं , हालांकि मुझे नहीं लगता कि हम इसे _that_ रस्ट में सामान्य बनाना चाहते हैं: try { 4 } ↦ vec![4] देना मुझे ओवरकिल जैसा लगता है .

मैं एक ऐसे भविष्य की भी कल्पना कर रहा हूं, जहां async फ़ंक्शन भविष्य में ब्लॉक मान को लपेटने के लिए प्रस्तावित हैं, हमारे पास try फ़ंक्शन हो सकते हैं जो ब्लॉक मान को एक गिरने योग्य प्रकार में लपेटते हैं। वहां, फिर से, TryContinue महत्वपूर्ण हिस्सा है - ऐसा फ़ंक्शन ? उपयोग भी नहीं कर सकता है, अगर हमें throw निर्माण मिलता है।

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

संपादित करें : क्षमा करें यदि आपको इसके प्रारंभिक संस्करण के साथ एक ईमेल मिला है; मैंने "टिप्पणी" बहुत जल्दी मारा ...

सबसे बड़ी चीज जो खोती है वह संपत्ति है जो टाइपोफ (एक्स?) केवल टाइपोफ (एक्स) पर निर्भर करती है।

आह हाँ, बिल्कुल। यह बात बताने के लिए धन्यवाद।

बेशक, ऐसे तर्क भी थे जो कहते थे कि संपत्ति अनावश्यक है या बहुत प्रतिबंधात्मक है, लेकिन अंतिम सारांश में इससे पहले कि FCP यह अभी भी एक लाभ के रूप में था (रस्ट-लैंग/आरएफसीएस#१८५९ (टिप्पणी))।

क्या कोई विशिष्ट उदाहरण हैं जहां यह बहुत अधिक प्रतिबंधात्मक हो सकता है?

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

मुझे लगता है कि यह एक निष्पक्ष विश्लेषण है। मैं सहमत हूं।

@SergioBenitez https://github.com/rust-lang/rfcs/pull/1859#issuecomment -279187967 से

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

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

ओटीओएच, मुझे इन पंक्तियों के साथ कोड में पठनीयता के बारे में कुछ चिंता है। यह केवल त्रुटि घटक को परिवर्तित करने से गुणात्मक रूप से भिन्न लगता है - इसका मतलब है कि मूल मिलान? प्रदर्शन किया जाएगा प्रासंगिक जानकारी पर निर्भर है।

तो कोई एक विशेषता की कल्पना कर सकता है जो _दोनों_ प्रकार को पैरामीटर टाइप करने के लिए स्थानांतरित कर देता है, जैसे

trait Try<T,E> {
    fn question(self) -> Either<T, E>;
}

और उपयोग करें कि सभी को सक्षम करें

let x: Result<_,_> = blah.poll()?; // early-return if NotReady
let x: Async<_> = blah.poll()?; // early-return if Error
let x: i32 = blah.poll()?; // early-return both NotReady and Errors

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

println!("{}", z?);
z?.method();

चूंकि उत्पादन करने के लिए कहने के लिए कोई प्रकार का संदर्भ नहीं है।

दूसरा संस्करण इस तरह की चीजों को सक्षम करना होगा:

fn foo() -> Result<(), Error> {
    // `x` is an Async<i32> because NotReady doesn't fit in Result
    let x = something_that_returns_poll()?;
}
fn bar() -> Poll<(), Error> {
    // `x` is just i32 because we're in a Poll-returning method
    let x = something_that_returns_poll()?;
}

मेरी वृत्ति वहाँ है कि अनुमान "बाहर बह रहा है?" वहाँ बहुत आश्चर्य की बात है, और इस प्रकार यह "बहुत चालाक" बाल्टी में है।

गंभीर रूप से, मुझे नहीं लगता कि इसका न होना बहुत अधिक प्रतिबंधात्मक है। my_result? एक -> Poll फ़ंक्शन में इसकी आवश्यकता नहीं है, क्योंकि सफलता का प्रकार हमेशा की तरह समान है (सिंक्रोनस कोड को एसिंक संदर्भों में समान काम करने के लिए महत्वपूर्ण) और त्रुटि संस्करण ठीक भी परिवर्तित होता है . का उपयोग करते हुए ? पर एक Poll एक विधि है कि रिटर्न में Result एक विरोधी पैटर्न की तरह वैसे भी लगता है, कुछ नहीं है कि आम होना चाहिए, इसलिए (काल्पनिक) की तरह समर्पित तरीकों का उपयोग कर .wait(): T (परिणाम के लिए ब्लॉक करने के लिए) या .ready(): Option<T> (यह जांचने के लिए कि क्या यह किया गया है) मोड चुनने के लिए शायद वैसे भी बेहतर है।

यह "दिलचस्प" है https://play.rust-lang.org/?gist=d3f2cd403981a631f30eba2c3166c1f4&version=nightly&mode=debug

मुझे ये कोशिश (पकड़ें) ब्लॉक पसंद नहीं हैं, वे बहुत नए लोगों के अनुकूल नहीं लगते हैं।

मैं प्रस्ताव की वर्तमान स्थिति को इकट्ठा करने की कोशिश कर रहा हूं, जो कई टिप्पणियों में फैला हुआ लगता है। क्या वर्तमान में प्रस्तावित लक्षणों के समूह का एक सारांश है (जो Error संबद्ध प्रकार को छोड़ देता है)?

इस धागे की शुरुआत में मुझे Try को त्रुटि लक्षणों से अलग/अलग में विभाजित करने के बारे में एक टिप्पणी दिखाई देती है - क्या उस विभाजन को लागू करने की कोई योजना है?

प्रश्न चिह्न पर Result<T, E> से किसी भी प्रकार के Other<T2, E> में पारदर्शी रूपांतरण होना उपयोगी होगा - यह मौजूदा आईओ कार्यों को अधिक विशिष्ट (उदाहरण के लिए) के साथ फ़ंक्शन के भीतर से अच्छे सिंटैक्स के साथ कॉल करने देगा। आलसी) वापसी प्रकार।

pub fn async_handler() -> AsyncResult<()> {
    let mut file = File::create("foo.txt")?;
    AsyncResult::lazy(move || {
        file.write_all(b"Hello, world!")?;
        AsyncResult::Ok(())
    })
}

अर्थ की दृष्टि से यह From::from(E) -> Other<T2, E> जैसा लगता है, लेकिन From का उपयोग वर्तमान में मौजूदा Result -समतुल्य Try कार्यान्वयन तक सीमित है।

मुझे सच में लगता है कि NoneError में एक अलग ट्रैकिंग समस्या होनी चाहिए। यहां तक ​​कि अगर Try विशेषता कभी स्थिर नहीं होती है, तो NoneError को स्थिर होना चाहिए क्योंकि यह ? पर Option अधिक एर्गोनोमिक बनाता है। struct MyCustomSemanthicalError; जैसी त्रुटियों या Default लागू करने वाली त्रुटियों के लिए इस पर विचार करें। None को आसानी से MyCustomSeemanthicalError में From<NoneError> माध्यम से परिवर्तित किया जा सकता है।

https://github.com/rust-analyzer/rust-analyzer/ पर काम करने में, मुझे ? ऑपरेटर में अपर्याप्तता से थोड़ा अलग पेपरकट मिला है, खासकर जब रिटर्न प्रकार Result<Option<T>, E> ।

इस प्रकार के लिए, यह ? लिए प्रभावी ढंग से desugar करने के लिए समझ में आता है:

match value? {
    None => return Ok(None),
    Some(it)=>it,
}

जहां value प्रकार का है Result<Option<V>, E> , या:

value?

जहां value है Result<V, E> । मेरा मानना ​​​​है कि यह संभव है यदि मानक पुस्तकालय Try को Option<T> लिए निम्नलिखित तरीके से लागू करते हैं, हालांकि मैंने स्पष्ट रूप से इसका परीक्षण नहीं किया है और मुझे लगता है कि विशेषज्ञता के मुद्दे हो सकते हैं।

enum NoneError<E> {
    None,
    Err(E),
}

impl From<T> for NoneError<T> {
    fn from(v: T) -> NoneError<T> {
        NoneError:Err(v)
    }
}

impl<T, E> std::Ops::Try for Result<Option<T>, E> {
    type OK = T;
    type Error = NoneError<E>;
    fn into_result(self) -> Result<Self::OK, Self::Error> {
        match self {
            Ok(option) => {
                if let Some(inner) = option {
                    Ok(inner)
                } else {
                    Err(NoneError::None)
                }
            }
            Err(error) => {
                Err(NoneError::Err(error));
            }
        }
    }
    fn from_error(v: Self::Error) -> Self {
        match v {
            NoneError::Err(error) => Err(error),
            None => Some(None),
        }
    }
    fn from_ok(v: Self::OK) -> Self {
        Ok(Some(v))
    }
}

impl<T> std::Ops::Try for Option<T> {
    type OK = T;
    type Error = NoneError<!>;
    fn into_result(self) -> Result<Self::OK, Self::Error> {
        match self {
            None => Err(NoneError::None),
            Some(v) => Ok(v),
        }
    }
    fn from_error(v: Self::Error) -> Self {
        match v {
            NoneError::None => Some(None),
            _ => unreachable!("Value of type ! obtained"),
        }
    }
    fn from_ok(v: Self::OK) -> Self {
        Ok(v)
    }
}

https://github.com/rust-lang/rust/issues/31436#issuecomment -441408288 से दोबारा पोस्ट करें क्योंकि मैं इस पर टिप्पणी करना चाहता था, लेकिन मुझे लगता है कि यह गलत मुद्दा था:

अनिवार्य रूप से, मेरे पास एक जीयूआई ढांचे में कॉलबैक है - 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
}

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

@joshtriplett इस पर वापस आने के लिए कुछ समय लेने के लिए खेद है। मैंने प्रस्ताव का एक कार्यशील प्रोटोटाइप https://github.com/rust-lang/rust/compare/master...scottmcm :try-trait-v2 पर ठोस होने के लिए एक साथ रखा है। मैं इसके साथ कुछ और चीजों को आजमाने की उम्मीद करता हूं।

@scottmcm क्या आपके पास परिवर्तनों की कुछ उच्च-स्तरीय व्याख्या है?

@scottmcm FWIW मैंने रेयान में भी आपके बदलावों की कोशिश की:
https://github.com/rayon-rs/rayon/compare/master...cuviper :try-trait-v2
(अभी भी अस्थिर वस्तुओं के बजाय निजी प्रतियों का उपयोग कर रहे हैं)

तो Option noneError को कन्वर्ट करने का उपाय क्या है? ऐसा लगता है कि, क्योंकि, यह ट्राई ट्रैट को लागू करता है, यह तब तक संकलित नहीं होगा जब तक आप उस विशेष (अस्थिर?) सुविधा का उपयोग करने में सक्षम नहीं होते।

तो मूल रूप से, आप इसका उपयोग नहीं कर सकते हैं? विकल्प के साथ ऑपरेटर जहां तक ​​​​मुझे पता है?

@omarabid , ऑपरेटर Option या Result साथ उपयोग के लिए स्थिर है, लेकिन आप स्थिर होने तक Try को सामान्य बाधा के रूप में उपयोग नहीं कर सकते। ? को Option पर Option लौटने वाले फ़ंक्शन में उपयोग करना बिल्कुल ठीक है, क्योंकि आपको NoneError को शामिल करने की आवश्यकता नहीं है। यदि आप प्रकार मिटाते हैं तो आप Result भी वापस कर सकते हैं:

use std::fmt::Debug;

pub struct Error(Box<dyn Debug>);

impl<T: Debug + 'static> From<T> for Error {
    fn from(error: T) -> Self {
        Error(Box::new(error))
    }
}

pub fn try_get<T>(slice: &[T], index: usize) -> Result<&T, Error> {
    Ok(slice.get(index)?)
}

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

@scottmcm , आपका प्रोटोटाइप try-trait-v2 इस उदाहरण में विफल रहता है!

अगर हम नहीं चाहते कि मेरा उदाहरण टूट जाए, तो try-trait-v2 को कुछ इस तरह की आवश्यकता होगी:

#[unstable(feature = "try_trait_v2", issue = "42327")]
impl<T, U, E: From<NoneError>> ops::Bubble<Result<U, E>> for Option<T> {
    fn bubble(self) -> ops::ControlFlow<T, Result<U, E>> {
        match self {
            Some(x) => ops::ControlFlow::Continue(x),
            None => ops::ControlFlow::Break(Err(E::from(NoneError))),
        }
    }
}

इस सुविधा की वर्तमान स्थिति क्या है?

पुनरावृत्तियों के लिए try_fold को लागू करने वाले दस्तावेज़ के पीआर #62606 को स्थिर होने के बाद फिर से खोला जाना चाहिए।

संपादित करें: उस के लिए एक ट्रैकिंग आइटम के साथ सेशन को अपडेट किया ~ scottmcm

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

@scottmcm के विकल्प का उपयोग करने से हम ? साथ Option का उपयोग कर सकेंगे और NoneError छुटकारा पा सकेंगे। मैं @nikomatsakis ( टिप्पणी ) से सहमत हूं कि Try विशेषता को " Option की 'विफलता' का प्रतिनिधित्व करने के लिए कृत्रिम रूप से परिभाषित करने की आवश्यकता को बढ़ावा नहीं देना चाहिए"।

pub struct Error(Box<dyn std::fmt::Debug>);
impl<T: std::fmt::Debug + 'static> From<T> for Error { fn from(error : T) -> Self { Error(Box::new(error)) } }
type Result<T> = std::result::Result<T, Error>;

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

• StdError के बजाय डीबग (StdError और noneError के लिए सामान्य) का उपयोग करना:
  एक सामान्य From<T: StdError> for Error और एक विशेष From<NoneError> for Error विरोध
  क्योंकि यह अस्पष्ट होगा यदि कोई नहीं त्रुटि ने StdError को लागू किया (जाहिरा तौर पर यहां तक ​​​​कि डिफ़ॉल्ट भी ओवरराइड की अनुमति नहीं देता है और विशिष्टता को लागू करता है)
  इसे "नकारात्मक बाध्य" द्वारा हल किया जा सकता है जो समर्थित नहीं है, शायद इसलिए कि यह एकमात्र उपयोग केस होगा? (विशेषज्ञता से अधिक)
  किसी भी त्रुटि के लिए impl StdError को केवल StdError या noneError के साथ ही परिभाषित किया जा सकता है, ताकि यह किसी भी डाउनस्ट्रीम में सुसंगत हो।
• त्रुटि एक उपनाम नहीं हो सकती:
  type Error = Box<Debug> डिबग को बांधता है जो From<T:Debug> for Error को From<T> for T साथ संघर्ष करता है (बेकार के लिए प्रतिवर्त)

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

fn from<T>(result : Result<T>) -> std::result::Result<T, Box<dyn std::fmt::Debug>> { match result { Ok(t) => Ok(t), Err(e) => Err(e.0) } }

यह impl From<Result<T>> for StdResult<T> और न ही Into<StdResult> for Result<T> हो सकता है (अपस्ट्रीम प्रकार के लिए अपस्ट्रीम विशेषता को लागू नहीं कर सकता)

उदाहरण के लिए, आप टर्मिनेशन के लिए डीबग रिटर्न प्राप्त करने के लिए इसका उपयोग कर सकते हैं:

fn main() -> std::result::Result<(), Box<dyn std::fmt::Debug>> { from(run()) }

बुरा विचार: शायद ? ऑपरेटर किसी तरह एक मोनैडिक बाइंड का प्रतिनिधित्व कर सकता है, इसलिए

let x: i32 = something?;
rest of function body

हो जाता है

Monad::bind(something, fn(x) {
    rest of function body
})

एक भयानक विचार, लेकिन यह मेरे भीतर के गीक को प्रसन्न करता है।

@derekdreery मुझे नहीं लगता कि यह return और continue जैसे अनिवार्य नियंत्रण प्रवाह के साथ अच्छी तरह से काम करेगा

ध्यान रखें कि ? ऑपरेटर के शब्दार्थ पहले से ही स्थिर हैं। केवल वास्तविक Try विशेषता अस्थिर है, और किसी भी परिवर्तन को Option और Result लिए समान स्थिर प्रभाव बनाए रखना चाहिए।

@कृष्णासनसी

@derekdreery मुझे नहीं लगता कि यह अनिवार्य नियंत्रण प्रवाह जैसे वापसी और जारी रखने के साथ अच्छी तरह से काम करेगा

मैं इस कथन से सहमत हूं।

@क्यूविपर

ध्यान रखें कि शब्दार्थ ? ऑपरेटर पहले से ही स्थिर हैं। केवल वास्तविक प्रयास विशेषता अस्थिर है, और किसी भी परिवर्तन को विकल्प और परिणाम के लिए समान स्थिर प्रभाव बनाए रखना चाहिए।

क्या यह युगों में भी सच है?

अधिक सामान्य नोट पर, मुझे नहीं लगता कि .await , ?/ जल्दी वापसी जैसी अवधारणाओं को एकीकृत करना संभव है, विकल्प :: नक्शा, परिणाम :: नक्शा, इटरेटर :: नक्शा जंग में, लेकिन यह समझते हुए कि ये सभी कुछ संरचना साझा करते हैं, निश्चित रूप से मुझे एक बेहतर प्रोग्रामर बनने में मदद करता है।

ओटी होने के लिए खेद है।

मुझे यकीन नहीं है कि एक युग/संस्करण को ? desugaring को बदलने की अनुमति दी जाएगी, लेकिन यह निश्चित रूप से मैक्रोज़ जैसी कई क्रॉस-क्रेट चिंताओं को जटिल करेगा।

स्थिरता की गारंटी और युग RFC के बारे में मेरी व्याख्या यह है कि ? व्यवहार (चीनी या अन्यथा) को बदला जा सकता है, लेकिन Option / Result प्रकारों पर इसका वर्तमान व्यवहार बना रहना चाहिए ऐसा इसलिए है क्योंकि इसे तोड़ने से हम जितना सही ठहराने की उम्मीद कर सकते हैं, उससे कहीं अधिक मंथन होगा।

क्या होगा यदि Option किसी तरह Result लिए एक प्रकार का उपनाम था? यानी type Option<T> = Result<T, NoValue> , Option::<T>::Some(x) = Result::<T, NoValue>::Ok(x) , Option::<T>::None = Result::<T, NoValue>::Err(NoValue) ? इसे लागू करने के लिए कुछ जादू लगेगा और वर्तमान भाषा के माहौल में यथार्थवादी नहीं है, लेकिन शायद यह तलाशने लायक है।

हम यह परिवर्तन नहीं कर सकते क्योंकि ऐसे लक्षण संकेत हैं जो Option और Result अलग-अलग प्रकार होने पर निर्भर करते हैं।

यदि हम इसे अनदेखा करते हैं, तो हम इसे एक कदम आगे ले जा सकते हैं और bool को Result<True, False> लिए एक उपनाम भी बना सकते हैं, जहां True और False इकाई प्रकार हैं।

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

या, इकाई को बाहर रखा गया था क्योंकि किसी भी स्थिति में त्रुटियों को चुपचाप अनदेखा नहीं करना पसंद किया जाता है?

इस। यदि आप गैर-महत्वपूर्ण संदर्भ में त्रुटियों को अनदेखा करना चाहते हैं तो आपको unwrap या इसके किसी एक प्रकार का उपयोग करना चाहिए।

उपयोग करने के लिए सक्षम किया जा रहा ? की तरह कुछ पर foo() -> () एक सशर्त संकलन संदर्भ में काफी उपयोगी होगा और दृढ़ता से विचार किया जाना चाहिए। मुझे लगता है कि हालांकि यह आपके प्रश्न से अलग है।

आपको अनरैप या इसके किसी एक प्रकार का उपयोग करना चाहिए।

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

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

उपयोग करने के लिए सक्षम किया जा रहा ? की तरह कुछ पर foo() -> () एक सशर्त संकलन संदर्भ में काफी उपयोगी होगा और दृढ़ता से विचार किया जाना चाहिए। मुझे लगता है कि हालांकि यह आपके प्रश्न से अलग है।

यह कैसे काम करेगा? बस हमेशा ठीक (()) का मूल्यांकन करें और अनदेखा करें?

साथ ही, क्या आप इसका उदाहरण दे सकते हैं कि आप इसका उपयोग कहां करना चाहते हैं?

हाँ विचार यह था कि MyCollection::push जैसा कुछ, संकलन समय कॉन्फ़िगरेशन के आधार पर, या तो परिणाम <(), AllocError> वापसी मान या () वापसी मान हो सकता है यदि संग्रह केवल त्रुटि पर घबराने के लिए कॉन्फ़िगर किया गया है। संग्रह का उपयोग करने वाले इंटरमीडिएट कोड को इसके बारे में सोचना नहीं चाहिए, इसलिए यदि यह केवल _always_ ? उपयोग कर सकता है, भले ही रिटर्न प्रकार () हो तो यह आसान होगा।

लगभग 3 वर्षों के बाद, क्या यह हल होने के करीब है?

@ लोकाथोर जो केवल तभी काम करेगा जब रिटर्न टाइप Result<Result<X,Y>,Z> या इससे मिलता-जुलता संभव न हो। लेकिन यह है। ऐसे में संभव नहीं है।

मुझे समझ में नहीं आता क्यों एक स्तरित परिणाम समस्या का कारण बनता है। क्या आप कृपया विस्तृत कर सकते हैं?

क्रॉस- रेफरेंसिंग उद्देश्यों के लिए,

https://internals.rust-lang.org/t/a-slightly-more-general-easier-to-implement-alternative-to-the-try-trait/12034

@लोकथोर
ठीक है, मैंने इसके बारे में और गहराई से सोचा और मुझे लगता है कि मुझे एक अच्छी व्याख्या मिल सकती है।

एनोटेशन का उपयोग करना

समस्या यह है कि रिटर्न प्रकार की व्याख्या या अजीब एनोटेशन कोड को अव्यवस्थित कर देगा। यह संभव होगा, लेकिन यह कोड को पढ़ने में कठिन बना देगा। (पूर्व शर्त: #[debug_result] आपके वांछित व्यवहार को लागू करता है, और Result::Err(...) लौटने के बजाय रिलीज मोड में घबराहट के लिए एक फ़ंक्शन को संशोधित करता है, और Result::Ok खोलता है, लेकिन वह हिस्सा मुश्किल है)

#[debug_result]
fn f() -> Result<X, Y>;

#[debug_result]
fn f2() -> Result<Result<A, B>, Y>;

#[debug_result]
fn g() -> Result<X, Y> {
    // #[debug_result_spoiled]
    let w = f();
    // w could have type X or `Result<X,Y>` based on a #[cfg(debug_...)]
    // the following line would currently only work half of the time
    // we would modify the behavoir of `?` to a no-op if #[cfg(not(debug_...))]
    // and `w` was marked as `#[debug_result]`-spoiled
    let x = w?;

    // but it gets worse; what's with the following:
    let y = f2();
    let z = y?;
    // it has completely different sematics based on a #[cfg(debug_...)],
    // but would (currently?) print no warnings or errors at all,
    // and the type of z would be differently.

    Ok(z)
}

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

// f3 is not annotated
fn f3() -> Result<X, Y>;

// later inside of a function:
   // z2 needs to be both marked spoiled and non-spoiled -> type error
   let z2 = if a() {
       f3()
   } else {
       f()
   };
   // althrough the following would be possible:
   let z2_ = if a() {
       f3()?
   } else {
       f()?
   };

वैकल्पिक: एक नए प्रकार का उपयोग करना

एक "क्लीनर" समाधान एक DebugResult<T, E> प्रकार हो सकता है जो एक निश्चित संकलन ध्वज सेट होने पर बस घबराता है और इसे एक त्रुटि से बनाया गया है, लेकिन अन्यथा Result<T, E> बराबर होगा। लेकिन यह मौजूदा प्रस्ताव के साथ भी संभव होगा, मुझे भी लगता है।

@zserik की अंतिम पोस्ट का उत्तर दें: आपके द्वारा वर्णित मैक्रो व्यर्थ है - बिल्ड कॉन्फ़िगरेशन के आधार पर फ़ंक्शन का रिटर्न प्रकार चार्ज करना फ़ंक्शन परिणाम पर प्रत्येक मैच को केवल एक को छोड़कर हर संभव बिल्ड कॉन्फ़िगरेशन में तोड़ देगा, चाहे वह किसी भी तरह से किया गया हो।

@ tema3210 मुझे पता है। मैं केवल यह बताना चाहता था कि @Lokathor का विचार आम तौर पर व्यवहार में काम नहीं करेगा। केवल एक चीज जो आंशिक रूप से काम कर सकती है वह निम्नलिखित है, लेकिन केवल कई प्रतिबंधों के साथ, जो मुझे नहीं लगता कि दीर्घकालिक में इसके लायक है:

// the result of the fn *must* have Try<Ok=()>
// btw. the macro could be already implemented with a proc_macro today.
#[debug_result]
fn x() -> Result<(), XError> {
  /* ..{xbody}.. */
}

// e.g. evaluates roughly to:
//..begin eval
fn x_inner() -> Result<(), XError> {
  /* ..{xbody}.. */
}

#[cfg(panic_on_err)]
fn x() {
  let _: () = x_inner().unwrap();
}
#[cfg(not(panic_on_err))]
fn x() -> Result<(), XError> {
  x_innner()
}

//..end eval

fn y() -> Result<(), YError> {
  /* ... */
  // #[debug_result] results can't be matched on and can't be assigned to a
  // variable, they only can be used together with `?`, which would create
  // an asymetry in the type system, but could otherwise work, althrough
  // usage would be extremely restricted.
  x()?;
  // e.g. the following would fail to compile because capturing the result
  // is not allowed
  if let Err(z) = x() {
    // ...
  }
}

@zserik क्या यह संभव है कि यह वास्तव में इस तरह का रूप लेता है?

#[cfg(panic_on_err)]
fn x() -> Result<(), !> {
  let _: () = x_inner().unwrap();
}

#[cfg(not(panic_on_err))]
fn x() -> Result<(), XError> {
  x_innner()
}

बढ़िया! अच्छा विचार है।

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

आपके पास एक विशेषता है जिसका उपयोग आप ट्रैकिंग जानकारी पास करने के लिए करते हैं जिसमें विशेषज्ञता का उपयोग होता है और पीछे की संगतता बनाए रखने के लिए टी के लिए एक डिफ़ॉल्ट इम्प्लांट होता है

pub trait Track {
    fn track(&mut self, location: &'static Location<'static>);
}

default impl<T> Track for T {
    fn track(&mut self, _: &'static Location<'static>) {}
}

और फिर आप Try कार्यान्वयन को Result के लिए track_caller का उपयोग करने के लिए संशोधित करते हैं और इस जानकारी को आंतरिक प्रकार में पास करते हैं,

    #[track_caller]
    fn from_error(mut v: Self::Error) -> Self {
        v.track(Location::caller());
        Self::Err(v)
    }

और फिर उन प्रकारों के लिए जिन्हें आप अपने लिए ट्रैक . लागू करने के लिए बैकट्रेस एकत्र करना चाहते हैं

#[derive(Debug, Default)]
pub struct ReturnTrace {
    frames: Vec<&'static Location<'static>>,
}

impl Track for ReturnTrace {
    fn track(&mut self, location: &'static Location<'static>) {
        self.frames.push(location);
    }
}

उपयोग समाप्त होता है इस तरह दिखता है

#![feature(try_blocks)]
use error_return_trace::{MyResult, ReturnTrace};

fn main() {
    let trace = match one() {
        MyResult::Ok(()) => unreachable!(),
        MyResult::Err(trace) => trace,
    };

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

fn one() -> MyResult<(), ReturnTrace> {
    try { two()? }
}

fn two() -> MyResult<(), ReturnTrace> {
    MyResult::Err(ReturnTrace::default())?
}

और बैकट्रेस के एक बहुत ही चमकदार संस्करण का आउटपुट इस तरह दिखता है

ReturnTrace { frames: [Location { file: "examples/usage.rs", line: 18, col: 42 }, Location { file: "examples/usage.rs", line: 14, col: 16 }] }

और यहाँ कार्रवाई में इसकी अवधारणा का प्रमाण है https://github.com/yaahc/error-return-traces

मैंने सोचा कि केवल एक त्रुटि प्रकार जिसे हम विशेषता कार्यान्वयनकर्ता का

trait Try{
     type Error;
     type Ok;
     fn into_result(self)->Result<Self::Ok,Self::Error>;
     fn from_ok(val: Self::Ok)->Self;
     fn from_error<T>(val: T)->Self;
}

ध्यान दें, वहां कंपाइलर from_error को मोनोमोर्फाइज कर सकता है, From::from कॉल से बच सकता है, और कोई अलग-अलग त्रुटि प्रकारों के लिए मैन्युअल रूप से विधि प्रदान कर सकता है, जिसके परिणामस्वरूप ? ऑपरेटर की क्षमता अलग-अलग "अनरैप" कर सकती है। त्रुटियों के प्रकार।

 fn from_error<T>(val: T)->Self;

जैसा कि लिखा गया है, कार्यान्वयनकर्ता को _any_ आकार T स्वीकार करना होगा, अप्रतिबंधित। यदि आप इसे कस्टम विवश होने देना चाहते हैं, तो इसे एक विशेषता पैरामीटर होना चाहिए, जैसे Try<T> । यह TryBlock / Bubble<Other> संयोजन के समान है जो @scottmcm में https://github.com/rust-lang/rust/issues/42327#issuecomment-457353299 में था।

जैसा लिखा है, कार्यान्वयनकर्ता को _any_ आकार T स्वीकार करना होगा, अप्रतिबंधित। यदि आप इसे कस्टम विवश होने देना चाहते हैं, तो इसे एक विशेषता पैरामीटर होना चाहिए, जैसे Try<T> । यह TryBlock / Bubble<Other> संयोजन के समान है जो @scottmcm में #42327 (टिप्पणी) में था ।

मेरा मतलब था कि उपयोग इस तरह दिखना चाहिए:

trait Try{
     //same from above
}
struct Dummy {
    a: u8,
}
struct Err1();
struct Err2();
impl Try for Dummy {
    type Ok=();
    type Error=();

    fn into_result(self)->Result<Self::Ok,Self::Error>{
        std::result::Result::Ok(())
    }
    fn from_ok(val: Self::Ok)->Self{
        Self{a: 0u8}
    }
    fn from_error<T>(val: Err1)->Self where T == Err1{
        Self{a: 1u8}
    }
    fn from_error<T>(val: Err2)->Self where T == Err2{
        Self{a: 2u8}
    }
}

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

(और मुझे अभी भी लगता है कि इसे "कोशिश" के बजाय "प्रचार" कहा जाना चाहिए था, लेकिन मैं पचाता हूं)

@ tema3210 मुझे लगता है कि मैं आपका इरादा समझता हूं, लेकिन यह मान्य जंग नहीं है।

@ SonyEx2

आपको कोशिश और TryFromError को विभाजित करने की आवश्यकता होगी।

ठीक है, इसलिए मैंने TryBlock / Bubble<Other> डिज़ाइन का उल्लेख किया है। हम उस नामकरण विकल्प पर बहस कर सकते हैं, लेकिन विचार यह था कि जल्दी वापसी हमेशा _errors_ के बारे में नहीं होती है। उदाहरण के लिए, बहुत सी आंतरिक Iterator विधियां कस्टम LoopState प्रकार का उपयोग कर रही हैं। find जैसी किसी चीज़ के लिए, आप जो खोज रहे हैं उसे ढूंढने में कोई त्रुटि नहीं है, लेकिन हम वहां पुनरावृत्ति को रोकना चाहते हैं।

https://github.com/rust-lang/rust/blob/3360cc3a0ea33c84d0b0b1163107b1c1acbf2a69/src/libcore/iter/mod.rs#L375 -L378

हम उस नामकरण विकल्प पर बहस कर सकते हैं, लेकिन विचार यह था कि जल्दी वापसी हमेशा त्रुटियों के बारे में नहीं होती है।

ठीक है कि मुझे "कोशिश" नाम क्यों पसंद नहीं है और "प्रचार" नाम पसंद करेंगे, क्योंकि यह "प्रारंभिक" वापसी का "प्रचार" करता है: पी

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

डीबग जानकारी (जैसे फ़ाइल/लाइन नंबर) लॉग करने के लिए लॉग हुक फ़े जोड़ने के लिए डिफ़ॉल्ट ? व्यवहार fe को ओवरराइट करने का प्रयास करते समय यह विशेषता किसी भी मदद की होगी?

वर्तमान में यह stdlib मैक्रोज़ को अधिलेखित करने के लिए समर्थित है, लेकिन ऐसा लगता है कि ? ऑपरेटर स्पष्ट रूप से try! मैक्रो में परिवर्तित नहीं होता है। बदकिस्मती से।

@stevenroose केवल Try विशेषता के लिए समर्थन जोड़ने के लिए, उस स्थान के बारे में फ़ाइल स्थान जानकारी शामिल करने के लिए Try विशेषता के संशोधन की आवश्यकता होगी जहां ? "हो गया" .

@stevenroose केवल Try विशेषता के लिए समर्थन जोड़ने के लिए, उस स्थान के बारे में फ़ाइल स्थान जानकारी शामिल करने के लिए Try विशेषता के संशोधन की आवश्यकता होगी जहां ? "हो गया" .

यह सच नहीं है, #[track_caller] का उपयोग लक्षणों पर किया जा सकता है, भले ही विशेषता परिभाषा में एनोटेशन शामिल न हो

@stevenroose आपके प्रश्न का उत्तर देने के लिए, हाँ, हालाँकि यदि आप सभी ? स्थानों को प्रिंट करने में रुचि रखते हैं, तो आपके माध्यम से एक त्रुटि का प्रचार करना चाहिए, ऊपर से त्रुटि वापसी ट्रेस टिप्पणी की जाँच करनी चाहिए

https://github.com/rust-lang/rust/issues/42327#issuecomment -619218371

मुझे यकीन नहीं है कि अगर किसी ने पहले ही इसका उल्लेख किया है, तो क्या हम impl Try for bool , शायद Try<Ok=(), Error=FalseError> ?
ताकि हम ऐसा कुछ कर सकें

fn check_key(v: Vec<A>, key: usize) -> bool {
  let x = v.get_mut(key)?; // Option
  x.is_valid()?; // bool
  x.transform()?; // Result
  true
}

अब मुझे ज्यादातर मामलों में रिटर्न टाइप Option<()> का उपयोग करना होगा जहां मुझे लगता है कि ? कोड को और अधिक स्पष्ट कर सकता है।

मुझे यकीन नहीं है कि अगर किसी ने पहले ही इसका उल्लेख किया है, तो क्या हम impl Try for bool , शायद Try<Ok=(), Error=FalseError> ?

यह Try को bool s पर && ऑपरेटर के रूप में व्यवहार करेगा। जैसा कि अन्य ने ऊपर बताया है, सफलता पर शॉर्ट-सर्किटिंग के लिए उपयोग के मामले भी हैं, ऐसे में Try को || रूप में व्यवहार करना चाहिए। चूंकि && और || ऑपरेटरों को टाइप करने में अधिक समय नहीं लगता है, इसलिए मुझे इस कार्यान्वयन के लिए बहुत अधिक लाभ नहीं दिखता है।

@calebsander कृपया उत्तर के लिए धन्यवाद।
यह कुछ साधारण मामलों के लिए सच है, लेकिन मुझे नहीं लगता कि अक्सर ऐसा होता है, विशेष रूप से हमारे पास कभी भी असाइनमेंट स्टेटमेंट जैसे let x = v.get_mut(key)? अभिव्यक्ति में नहीं हो सकता है।
अगर && और || हमेशा चाल चलेंगे, तो हम .unwrap_or_else() , .and_then() के साथ Option और Error मामले।
क्या आप प्रवाहित कोड को && और || में व्यक्त कर सकते हैं?

fn check_key(v: Vec<A>, key: usize) -> bool {
  let x = v.get_mut(key)?; // Option
  x.not_valid().not()?; // bool
  for i in x.iter() {
    if i == 1 { return true }
    if i == 2 { return false }
    debug!("get {}" i);
  }
  let y = x.transform()?; // Result
  y == 1
}

कुछ शर्तों के लिए कि true अर्थ विफल हो गया है जबकि false अर्थ सफलता है, !expr? भ्रमित करने वाला हो सकता है, लेकिन हम चाल करने के लिए expr.not()? का उपयोग कर सकते हैं (नोट: के लिए ops::Try , हमारे पास हमेशा false लिए Error )

यह कुछ साधारण मामलों के लिए सच है, लेकिन मुझे नहीं लगता कि अक्सर ऐसा होता है, विशेष रूप से हमारे पास कभी भी असाइनमेंट स्टेटमेंट जैसे let x = v.get_mut(key)? अभिव्यक्ति में नहीं हो सकता है।

ठीक है, जब तक मैं आपके प्रस्ताव को गलत नहीं समझता, केवल Try<Ok = (), Error = FalseError> लिए bool को लागू करने से इसकी अनुमति नहीं होगी। आपको impl From<NoneError> for FalseError की भी आवश्यकता होगी ताकि ? ऑपरेटर None को false परिवर्तित कर सके। (और इसी तरह, आप लागू करना चाहते है, तो ? करने के लिए एक Result<T, E> के अंदर एक समारोह है कि रिटर्न bool , आप की आवश्यकता होगी impl From<E> for FalseError । मुझे लगता है कि इस तरह के एक कंबल कार्यान्वयन समस्याग्रस्त होगा।) आप केवल some_option().ok_or(false)? और some_result().map_err(|_| false)? कर सकते हैं यदि आप वापसी मूल्य Result<bool, bool> साथ ठीक हैं (जिसे आप .unwrap_or_else(|err| err) साथ संक्षिप्त कर सकते हैं

अन्य Try त्रुटियों को bool में परिवर्तित करने के मुद्दों को छोड़कर, Try कार्यान्वयन जो आप bool लिए प्रस्तावित कर रहे हैं वह केवल && ऑपरेटर है। उदाहरण के लिए, ये समकक्ष हैं

fn using_try() -> bool {
    some_bool()?;
    some_bool()?;
    some_bool()
}

तथा

fn using_and() -> bool {
    some_bool() &&
    some_bool() &&
    some_bool()
}

(जाहिर है, if और loop जैसे नियंत्रण प्रवाह जो गैर- () लौटाते हैं, अनुवाद करने के लिए कम सरल हैं।)

कुछ शर्तों के लिए कि true अर्थ विफल हो गया है जबकि false अर्थ सफलता है, !expr? भ्रमित करने वाला हो सकता है, लेकिन हम चाल करने के लिए expr.not()? का उपयोग कर सकते हैं (नोट: के लिए ops::Try , हमारे पास हमेशा false लिए Error )

मुझे यह स्पष्ट नहीं है कि false को Error मामले का प्रतिनिधित्व करना चाहिए। (उदाहरण के लिए, Iterator.all() चाहेगा false शॉर्ट सर्किट के लिए, लेकिन Iterator::any() चाहेगा true बजाय।) आपके कहे, तो आप प्राप्त कर सकते हैं पास किए गए मान को ? (और फ़ंक्शन के रिटर्न मान को भी उलट कर) विपरीत शॉर्ट-सर्किटिंग व्यवहार। लेकिन मुझे नहीं लगता कि इसका परिणाम बहुत पठनीय कोड में होता है। दो अलग-अलग व्यवहारों को लागू करने वाले struct s And(bool) और Or(bool) को अलग करने का अधिक अर्थ हो सकता है।

और इसी तरह, यदि आप आवेदन करना चाहते हैं? एक परिणाम के लिएएक फ़ंक्शन के अंदर जो बूल लौटाता है, आपको From . को लागू करने की आवश्यकता होगीझूठी त्रुटि के लिए। मुझे लगता है कि ऐसा कंबल कार्यान्वयन समस्याग्रस्त होगा।

नहीं, मैं impl From<T> for FalseError नहीं चाहता, शायद हम result.ok()? कर सकें

यह मेरे लिए स्पष्ट नहीं है कि असत्य को त्रुटि मामले का प्रतिनिधित्व करना चाहिए।

मुझे लगता है कि यह किसी भी तरह स्वाभाविक है जब हमारे पास bool::then जो true से Some नक्शा है।

अगर मैं चूक गया तो मुझे क्षमा करें - NoneError अर्थ std::error::Error क्यों नहीं है? यह Box<dyn Error> या इसी तरह के किसी भी फ़ंक्शन को वापस करने के लिए बेकार बनाता है।

अगर मैं चूक गया तो मुझे क्षमा करें - NoneError अर्थ std::error::Error क्यों नहीं है? यह Box<dyn Error> या इसी तरह के किसी भी फ़ंक्शन को वापस करने के लिए बेकार बनाता है।

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

मैं @ErichDonGubler से सहमत हूं। ? साथ Option का उपयोग करने में असमर्थ होना बहुत कष्टप्रद है, हालांकि यह एक अच्छे कारण के लिए है, और, एक भाषा उपयोगकर्ता के रूप में, मुझे लगता है कि त्रुटियों को ठीक से संभालना हर किसी के हित में है। केवल ? None करने के बजाय त्रुटि संदर्भ को

केवल एक बार जब मैं None को त्रुटि के रूप में व्याख्या करने की अनुमति दूंगा, वह बहुत ही मोटे प्रोटोटाइप पर है। मैंने सोचा, अगर हम Option::todo_err() कॉल की तरह कुछ जोड़ते हैं, तो यह आंतरिक मूल्य के Ok लौटाएगा, लेकिन None । जब तक आप कोड संलेखन के "रफ प्रोटोटाइपिंग" मोड की जरूरतों का विश्लेषण नहीं करते हैं, तब तक यह बहुत प्रति-सहज है। यह बहुत हद तक Ok(my_option.unwrap()) , लेकिन इसके लिए Ok(...) रैपिंग की आवश्यकता नहीं है। इसके अलावा, यह स्पष्ट रूप से "टूडू" प्रकृति को निर्दिष्ट करता है, इस प्रकार इस कोड को उत्पादन तर्क से हटाने के इरादे से संचार करता है, इसे उचित त्रुटि बाध्यकारी के साथ बदल देता है।

लेकिन घबराएगा कोई नहीं

दृढ़ता से महसूस करें कि हमें इसे केवल unwrap छोड़ देना चाहिए। यदि हमने एक todo_err जोड़ा है तो उसे एक वास्तविक त्रुटि प्रकार वापस करना चाहिए, जो यह प्रश्न पूछता है कि किस त्रुटि प्रकार को वापस करना है।

इसके अलावा मुझे संदेह है कि fn todo_err(self) -> Result<Self, !> ! को स्थिर करने के लिए

मेरा उपयोगकेस वास्तव में मोटा प्रोटोटाइप है जहां मुझे त्रुटियों की बहुत अधिक परवाह नहीं है। क्या आपके द्वारा सूचीबद्ध इन समस्याओं से संपूर्ण NoneError पीड़ित नहीं है? अगर यह तय किया जाता है कि यह अस्तित्व में होना चाहिए (जो मुझे लगता है कि एक अच्छी बात है, कम से कम प्रोटोटाइप के लिए), मेरा मानना ​​​​है कि इसे Error को लागू करना चाहिए क्योंकि इसे एक नाम दिया गया है।

इस प्रकार की कमी के कारण मैंने उस पर केवल .ok_or("error msg") थप्पड़ मारने का सहारा लिया, जो काम भी करता है लेकिन कम सुविधाजनक है।