Rust: 'इम्प्ल ट्रैट' के लिए ट्रैकिंग समस्या (RFC 1522, RFC 1951, RFC 2071)

@aturon क्या हम वास्तव में RFC को रिपॉजिटरी में रख सकते हैं? ( @mbrubeck ने वहां टिप्पणी की कि यह एक समस्या थी।)

किया हुआ।

कार्यान्वयन का पहला प्रयास #35091 है (दूसरा, यदि आप पिछले वर्ष से मेरी शाखा की गणना करते हैं)।

एक समस्या जिसका मैं सामना कर रहा था, वह है जीवन काल के साथ। टाइप अनुमान क्षेत्र चर _everywhere_ रखना पसंद करता है और बिना किसी क्षेत्र-जांच परिवर्तन के, वे चर स्थानीय क्षेत्रों के अलावा किसी अन्य चीज़ का अनुमान नहीं लगाते हैं।
हालांकि, ठोस प्रकार _must_ निर्यात योग्य होना चाहिए, इसलिए मैंने इसे 'static सीमित कर दिया और स्पष्ट रूप से प्रारंभिक-बाध्य जीवनकाल पैरामीटर नामित किया, लेकिन यदि कोई फ़ंक्शन शामिल है तो यह _never_ उनमें से कोई भी है - यहां तक ​​​​कि एक स्ट्रिंग अक्षर भी अनुमान नहीं लगाता है 'static , यह काफी हद तक पूरी तरह से बेकार है।

एक बात जो मैंने सोची थी, उसका क्षेत्र-जाँच पर 0 प्रभाव पड़ेगा, वह है जीवन काल को मिटाना:

• impl Trait के ठोस प्रकार को उजागर करने वाला कुछ भी जीवन काल की परवाह नहीं करना चाहिए - Reveal::All लिए एक त्वरित खोज से पता चलता है कि पहले से ही संकलक में मामला है
• किसी फ़ंक्शन के रिटर्न प्रकार में impl Trait सभी ठोस प्रकारों पर एक बाध्यता रखी जानी चाहिए, कि यह उस फ़ंक्शन की कॉल को रेखांकित करता है - इसका मतलब है कि कोई भी जीवनकाल, आवश्यकता के अनुसार, 'static या फ़ंक्शन के आजीवन मापदंडों में से एक - _even_ अगर हम यह नहीं जान सकते हैं कि कौन सा (जैसे " 'a और 'b ")
• हमें impl Trait के अंतर्निहित आजीवन पैरामीट्रिस्म के लिए एक विचरण का चयन करना चाहिए (अर्थात दायरे में सभी आजीवन मापदंडों पर, प्रकार के मापदंडों के समान): इनवेरिएंस सबसे आसान है और कैली को अधिक नियंत्रण देता है, जबकि कॉन्ट्रावेरिएंस कॉल करने वाले को करने देता है अधिक और यह जाँचने की आवश्यकता होगी कि रिटर्न प्रकार में हर जीवनकाल एक विपरीत स्थिति में है (समान रूप से अपरिवर्तनीय के बजाय सहसंयोजक प्रकार के पैरामीट्रिस्म के साथ)
• ऑटो ट्रैट लीकिंग मैकेनिज्म के लिए आवश्यक है कि एक विशेषता बाध्य को कंक्रीट प्रकार पर रखा जा सकता है, दूसरे फ़ंक्शन में - चूंकि हमने जीवनकाल मिटा दिया है और पता नहीं है कि जीवनकाल कहां जाता है, कंक्रीट प्रकार में हर मिटाए गए जीवनकाल को प्रतिस्थापित करना होगा एक ताजा अनुमान चर के साथ जो सभी वास्तविक जीवनकाल मापदंडों में से सबसे कम जीवनकाल से कम नहीं होने की गारंटी है; समस्या इस तथ्य में निहित है कि विशेषता निहितार्थों को मजबूत आजीवन संबंधों की आवश्यकता हो सकती है (उदाहरण के लिए X<'a, 'a> या X<'static> ), जिसका पता लगाया जाना चाहिए और त्रुटिपूर्ण होना चाहिए, क्योंकि वे उन लोगों के लिए सिद्ध नहीं हो सकते हैं जीवन काल

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

cc @rust-lang/lang

@eddyb

लेकिन जीवनकाल _are_ impl Trait साथ महत्वपूर्ण - जैसे

fn get_debug_str(s: &str) -> impl fmt::Debug {
    s
}

fn get_debug_string(s: &str) -> impl fmt::Debug {
    s.to_string()
}

fn good(s: &str) -> Box<fmt::Debug+'static> {
    // if this does not compile, that would be quite annoying
    Box::new(get_debug_string())
}

fn bad(s: &str) -> Box<fmt::Debug+'static> {
    // if this *does* compile, we have a problem
    Box::new(get_debug_str())
}

मैंने उल्लेख किया है कि RFC थ्रेड्स में कई बार

विशेषता-वस्तु-रहित संस्करण:

fn as_debug(s: &str) -> impl fmt::Debug;

fn example() {
    let mut s = String::new("hello");
    let debug = as_debug(&s);
    s.truncate(0);
    println!("{:?}", debug);
}

यह as_debug की परिभाषा के आधार पर या तो यूबी है या नहीं।

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

@ arielb1 क्या हमारे पास एक सख्त 'a outlives 'b इंस्टा-फेल करना एक बुरा विचार नहीं हो सकता है, जहां 'a _anything_ 'static या आजीवन पैरामीटर के अलावा अन्य है और 'b एक ठोस प्रकार के impl Trait में प्रकट होता है।

यहाँ वापस लिखने के लिए कुछ समय देने के लिए क्षमा करें। तो मैं सोच रहा था
इस समस्या के बारे में। मेरी भावना यह है कि हमें अंततः (और .) करना पड़ता है
एक नई तरह की बाधा के साथ रीजन का विस्तार करना चाहते हैं - मैं इसे कॉल करूंगा
एक \in बाधा, क्योंकि यह आपको '0 \in {'a, 'b, 'c} जैसा कुछ कहने की अनुमति देता है, जिसका अर्थ है कि '0 लिए उपयोग किया जाने वाला क्षेत्र होना चाहिए
या तो 'a , 'b , या 'c । मुझे यकीन नहीं है कि एकीकृत करने का सबसे अच्छा तरीका है
इसे स्वयं हल करने में - निश्चित रूप से यदि \in सेट एक सिंगलटन है
सेट, यह सिर्फ एक समान संबंध है (जो वर्तमान में हमारे पास नहीं है a
प्रथम श्रेणी की चीज, लेकिन जिसे दो सीमाओं से बनाया जा सकता है), लेकिन
अन्यथा यह चीजों को जटिल बना देता है।

यह सब क्षेत्र की बाधाओं के समूह को बनाने की मेरी इच्छा से संबंधित है
आज हमारे पास जो है उससे कहीं अधिक अभिव्यंजक। निश्चित रूप से कोई एक की रचना कर सकता है
\in बाधा OR और == बाधाओं में से। लेकिन निश्चित रूप से अधिक
अभिव्यंजक बाधाओं को हल करना कठिन है और \in अलग नहीं है।

जो भी हो, मैं यहाँ अपनी सोच के बारे में कुछ बता दूँ। आइए इसके साथ काम करें
उदाहरण:

pub fn foo<'a,'b>(x: &'a [u32], y: &'b [u32]) -> impl Iterator<Item=u32> {...}

मुझे लगता है कि impl Trait लिए सबसे सटीक डिसुगरिंग शायद एक है
नया प्रकार:

pub struct FooReturn<'a, 'b> {
    field: XXX // for some suitable type XXX
}

impl<'a,'b> Iterator for FooReturn<'a,'b> {
    type Item = <XXX as Iterator>::Item;
}

अब impl Iterator<Item=u32> में foo को वैसा ही व्यवहार करना चाहिए जैसा
FooReturn<'a,'b> व्यवहार करेगा। हालांकि यह एक परफेक्ट मैच नहीं है। एक
अंतर, उदाहरण के लिए, विचरण है, जैसा कि eddyb लाया गया - मैं हूँ
यह मानते हुए कि हम impl Foo -समान प्रकार को प्रकार पर अपरिवर्तनीय बना देंगे
foo पैरामीटर। हालाँकि, ऑटो विशेषता व्यवहार काम करता है।
(एक अन्य क्षेत्र जहां मैच आदर्श नहीं हो सकता है यदि हम कभी भी जोड़ दें
impl Iterator अमूर्तता को "छेदने" की क्षमता, ताकि कोड
"अंदर" अमूर्त सटीक प्रकार जानता है - फिर यह क्रमबद्ध होगा
का एक अंतर्निहित "अनरैप" ऑपरेशन हो रहा है।)

कुछ मायनों में एक बेहतर मैच एक तरह के सिंथेटिक गुण पर विचार करना है:

trait FooReturn<'a,'b> {
    type Type: Iterator<Item=u32>;
}

impl<'a,'b> FooReturn<'a,'b> for () {
    type Type = XXX;
}

अब हम impl Iterator प्रकार को <() as FooReturn<'a,'b>>::Type जैसा मान सकते हैं। यह भी एक संपूर्ण मैच नहीं है, क्योंकि हम
सामान्य रूप से इसे सामान्य कर देगा। आप विशेषज्ञता का उपयोग करने की कल्पना कर सकते हैं
हालांकि इसे रोकने के लिए:

trait FooReturn<'a,'b> {
    type Type: Iterator<Item=u32>;
}

impl<'a,'b> FooReturn<'a,'b> for () {
    default type Type = XXX; // can't really be specialized, but wev
}

इस मामले में, <() as FooReturn<'a,'b>>::Type सामान्य नहीं होगा,
और हमारे पास बहुत करीबी मैच है। विचरण, विशेष रूप से, व्यवहार करता है
अधिकार; अगर हम कभी कुछ प्रकार चाहते हैं जो "अंदर" हों
अमूर्त, वे वही होंगे लेकिन उन्हें अनुमति है
सामान्य करना। हालांकि, एक पकड़ है: ऑटो विशेषता सामान नहीं है
काफी काम। (हम यहां सामंजस्य बिठाने पर विचार कर सकते हैं,
वास्तव में।)

वैसे भी, इन संभावित desugarings की खोज में मेरी बात यह नहीं है
सुझाव है कि हम "प्रत्यारोपित विशेषता" को एक _actual_ desugaring . के रूप में लागू करते हैं
(हालांकि यह अच्छा हो सकता है...) लेकिन हमारे काम के लिए एक अंतर्ज्ञान देने के लिए। मैं
लगता है कि दूसरा desugaring -- अनुमानों के संदर्भ में -- है a
हमें आगे बढ़ाने के लिए काफी मददगार।

एक जगह है कि यह प्रक्षेपण desugaring वास्तव में एक उपयोगी गाइड है
"जीवन काल" संबंध। अगर हम जांचना चाहते हैं कि क्या <() as FooReturn<'a,'b>>::Type: 'x , RFC 1214 हमें बताता है कि हम इसे साबित कर सकते हैं
जब तक 'a: 'x _और_ 'b: 'x धारण करता है। यह मुझे लगता है कि हम कैसे चाहते हैं
इम्प्लांट विशेषता के लिए चीजों को संभालने के लिए भी।

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

यदि आप संरचना को डिसुगरिंग या इम्प्लांट दोनों को देखते हैं, तो वहाँ है a
(जंग की शाब्दिक संरचना में निहित) प्रतिबंध जो XXX कर सकते हैं
केवल 'static या लाइफटाइम जैसे 'a और 'b , जो
फ़ंक्शन हस्ताक्षर में दिखाई देते हैं। यही वह चीज है जो हम नहीं हैं
यहाँ मॉडलिंग। मुझे यकीन नहीं है कि इसे करने का सबसे अच्छा तरीका है - कुछ प्रकार
अनुमान योजनाओं में स्कोपिंग का अधिक प्रत्यक्ष प्रतिनिधित्व होता है, और
क्लोजर में हमारी मदद करने के लिए, मैं हमेशा इसे रस्ट में जोड़ना चाहता हूं। लेकिन
मुझे लगता है कि पहले छोटे डेल्टा के बारे में सोचते हैं।

यहीं से \in बाधा आती है। कोई जोड़ने की कल्पना कर सकता है
एक टाइप-चेक नियम जो (मूल रूप से) FR(XXX) \subset {'a, 'b} --
जिसका अर्थ है कि XXX में प्रदर्शित होने वाले "मुक्त क्षेत्र" केवल 'a और
'b । यह \in आवश्यकताओं के लिए अनुवाद करना समाप्त कर देगा
विभिन्न क्षेत्र जो XXX में दिखाई देते हैं।

आइए एक वास्तविक उदाहरण देखें:

fn foo<'a,'b>(x: &'a [u32], y: &'b [u32]) -> impl Iterator<Item=u32> {
    if condition { x.iter().cloned() } else { y.iter().cloned() }
}

यहां, अगर condition सच है तो टाइप कुछ इस तरह होगा
Cloned<SliceIter<'a, i32>> । लेकिन अगर condition गलत है, तो हम करेंगे
Cloned<SliceIter<'b, i32>> । बेशक दोनों ही मामलों में हम करेंगे
कुछ इस तरह से हवा दें (प्रकार/क्षेत्र चर के लिए संख्याओं का उपयोग करके):

Cloned<SliceIter<'0, i32>> <: 0
'a: '0 // because the source is x.iter()
Cloned<SliceIter<'1, i32>> <: 0
'b: '1 // because the source is y.iter()

अगर हम वेरिएबल 0 से Cloned<SliceIter<'2, i32>> को इंस्टेंट करते हैं,
हमारे पास '0: '2 और '1: '2 , या क्षेत्र संबंधों का कुल सेट है
पसंद:

'a: '0
'0: '2
'b: '1
'1: '2
'2: 'body // the lifetime of the fn body

तो हमें '2 लिए किस मूल्य का उपयोग करना चाहिए? हमारे पास अतिरिक्त भी है
बाधा है कि '2 in {'a, 'b} । एफएन के रूप में लिखा के साथ, मुझे लगता है कि हम
एक त्रुटि की रिपोर्ट करनी होगी, क्योंकि न तो 'a और न ही 'b एक है
सही विकल्प। दिलचस्प है, हालांकि, अगर हम बाधा 'a: 'b जोड़ते हैं, तो एक सही मूल्य ( 'b ) होगा।

ध्यान दें कि अगर हम सिर्फ _सामान्य_ एल्गोरिदम चलाते हैं, तो हम इसके साथ समाप्त हो जाएंगे
'2 होने के नाते 'body । मुझे यकीन नहीं है कि \in संबंधों को कैसे संभालना है
संपूर्ण खोज को छोड़कर (हालांकि मैं कुछ विशेष की कल्पना कर सकता हूं
मामले)।

ठीक है, वह उतना ही दूर है जितना मुझे मिला है। =)

पीआर #35091 पर, @arielb1 ने लिखा:

मुझे "सभी जीवनकालों को निहित विशेषता में कैप्चर करना" दृष्टिकोण पसंद नहीं है और मैं आजीवन elision की तरह कुछ और पसंद करूंगा।

मैंने सोचा कि यहाँ चर्चा करना अधिक उचित होगा। @ arielb1 , क्या आप अपने मन में जो कुछ भी सोच रहे हैं उस पर और विस्तार कर सकते हैं? उपमा मैं ऊपर बना के संदर्भ में, मुझे लगता है कि आप मूल रूप से, के बारे में "प्रूनिंग" जीवन काल के उस समूह के newtype पर या में प्रक्षेपण मानकों (यानी के रूप में या तो प्रकट होता बात कर रहे हैं <() as FooReturn<'a>>::Type के बजाय <() as FooReturn<'a,'b>>::Type या कुछ और?

मुझे नहीं लगता कि लाइफटाइम एलिजन नियम इस संबंध में एक अच्छा मार्गदर्शक होगा: यदि हमने केवल &self के जीवनकाल को केवल शामिल करने के लिए चुना है, तो हम जरूरी नहीं कि इसमें शामिल हो सकें Self संरचना से पैरामीटर टाइप करें, न ही विधि से पैरामीटर टाइप करें, क्योंकि उनके पास WF स्थितियां हो सकती हैं जिनके लिए हमें कुछ अन्य जीवनकालों का नाम देना होगा।

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

मैंने कहीं भी चर्चा की गई गोपनीयता के साथ impl Trait बातचीत नहीं देखी।
अब fn f() -> impl Trait एक निजी प्रकार S: Trait समान रूप से विशेषता वस्तुओं fn f() -> Box<Trait> लौटा सकता है। यानी निजी प्रकार की वस्तुएं गुमनाम रूप में अपने मॉड्यूल के बाहर स्वतंत्र रूप से चल सकती हैं।
यह उचित और वांछनीय लगता है - प्रकार ही एक कार्यान्वयन विवरण है, केवल इसका इंटरफ़ेस, सार्वजनिक विशेषता के माध्यम से उपलब्ध Trait सार्वजनिक है।
हालांकि विशेषता वस्तुओं और impl Trait बीच एक अंतर है। अकेले विशेषता वस्तुओं के साथ निजी प्रकार की सभी विशेषता विधियों को आंतरिक संबंध मिल सकता है, वे अभी भी फ़ंक्शन पॉइंटर्स के माध्यम से कॉल करने योग्य होंगे। impl Trait के साथ निजी प्रकार की विशेषता विधियां अन्य अनुवाद इकाइयों से सीधे कॉल करने योग्य हैं। प्रतीकों के "आंतरिककरण" करने वाले एल्गोरिदम को केवल impl Trait साथ अज्ञात नहीं किए गए प्रकारों के लिए, या बहुत निराशावादी होने के तरीकों को आंतरिक बनाने के लिए कठिन प्रयास करना होगा।

@nikomatsakis

foo लिखने का "स्पष्ट" तरीका होगा

fn foo<'a: 'c,'b: 'c,'c>(x: &'a [u32], y: &'b [u32]) -> impl Iterator<Item=u32> + 'c {
    if condition { x.iter().cloned() } else { y.iter().cloned() }
}

यहां जीवन भर के लिए बाध्य होने का कोई सवाल ही नहीं है। जाहिर है, हर बार लाइफटाइम बाउंड लिखना काफी दोहराव वाला होगा। हालाँकि, जिस तरह से हम उस तरह की पुनरावृत्ति से निपटते हैं, वह आम तौर पर जीवन भर के लिए होता है। foo के मामले में, elision विफल हो जाएगा और प्रोग्रामर को स्पष्ट रूप से जीवनकाल निर्दिष्ट करने के लिए मजबूर करेगा।

मैं खोजकर्ता -संवेदी आजीवन @eddyb ने केवल impl Trait के विशिष्ट मामले में किया था और अन्यथा नहीं।

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

ऐसा लगता है कि यह हमेशा ऐसा नहीं होता है कि "एकल आजीवन पैरामीटर" पर्याप्त होता है:

fn foo<'a, 'b>(x: &'a [u32], y: &'b [u32]) -> impl Iterator<Item=u32> {
    x.iter().chain(y).cloned()
}

इस मामले में, छुपा इटरेटर प्रकार 'a और 'b दोनों को संदर्भित करता है (हालांकि यह उन दोनों में _is_ प्रकार है, लेकिन मुझे लगता है कि हम एक उदाहरण के साथ आ सकते हैं जो अपरिवर्तनीय है)।

तो @aturon और मैंने इस मुद्दे पर कुछ चर्चा की और मैं साझा करना चाहता था। यहाँ वास्तव में कुछ ऑर्थोगोनल प्रश्न हैं और मैं उन्हें अलग करना चाहता हूँ। पहला सवाल यह है कि "छिपे हुए प्रकार में संभावित रूप से किस प्रकार/आजीवन पैरामीटर का उपयोग किया जा सकता है?" default type में (अर्ध-) desugaring के संदर्भ में, यह "हमारे द्वारा पेश की जाने वाली विशेषता पर किस प्रकार के पैरामीटर दिखाई देते हैं" के लिए नीचे आता है। तो, उदाहरण के लिए, यदि यह फ़ंक्शन:

fn foo<'a, 'b, T>() -> impl Trait { ... }

कुछ इस तरह से desugared हो जाएगा:

fn foo<'a, 'b, T>() -> <() as Foo<...>>::Type { ... }
trait Foo<...> {
  type Type: Trait;
}
impl<...> Foo<...> for () {
  default type Type = /* inferred */;
}

तो यह प्रश्न नीचे आता है " Foo और उसके निहितार्थ पर किस प्रकार के पैरामीटर दिखाई देते हैं"? मूल रूप से, यहां ... । स्पष्ट रूप से इसमें Trait द्वारा उपयोग किए जाने वाले प्रकार पैरामीटर का सेट शामिल है, लेकिन अतिरिक्त प्रकार पैरामीटर क्या हैं? (जैसा कि मैंने पहले उल्लेख किया है, ऑटो लक्षणों के रिसाव को छोड़कर यह desugaring 100% वफादार है, और मैं तर्क दूंगा कि हमें विशेष इम्प्लांट्स के लिए ऑटो लक्षण भी लीक करना चाहिए।)

हम जिस डिफ़ॉल्ट उत्तर का उपयोग कर रहे हैं वह "सभी" है, इसलिए यहां ... 'a, 'b, T (किसी भी अज्ञात पैरामीटर के साथ जो प्रकट हो सकता है) होगा। यह _may_ एक उचित डिफ़ॉल्ट हो, लेकिन यह _necessily_ सर्वोत्तम डिफ़ॉल्ट नहीं है। (जैसा कि @ arielb1 ने बताया।)

यह जीवन के संबंध पर प्रभाव डालता है, क्योंकि, यह निर्धारित करने के लिए कि <() as Foo<...>>::Type ( impl Trait कुछ विशेष, अपारदर्शी तात्कालिकता का जिक्र करते हुए) 'x जीवित है, हमें प्रभावी रूप से दिखाना चाहिए वह ...: 'x (अर्थात, प्रत्येक जीवनकाल और प्रकार पैरामीटर)।

यही कारण है कि मैं कहता हूं कि यह जीवन भर के मापदंडों पर विचार करने के लिए पर्याप्त नहीं है: कल्पना करें कि हमारे पास foo जैसे foo::<'a0, 'b0, &'c0 i32> लिए कुछ कॉल है। इसका तात्पर्य यह है कि सभी तीन जीवनकाल, '[abc]0 , 'x निकल जाना चाहिए - दूसरे शब्दों में, जब तक वापसी मूल्य उपयोग में है, यह फ़ंक्शन में दिए गए सभी डेटा के ऋण को बढ़ा देगा . लेकिन, जैसा कि @ arielb1 ने बताया, एलिसन बताता है कि यह आमतौर पर आवश्यकता से अधिक लंबा होगा।

तो मैं कल्पना करता हूं कि हमें जो चाहिए वह है:

• एक उचित डिफ़ॉल्ट पर समझौता करने के लिए, शायद एलिशन से अंतर्ज्ञान का उपयोग करना;
• डिफ़ॉल्ट उपयुक्त नहीं होने पर एक स्पष्ट वाक्यविन्यास रखने के लिए।

@aturon ने स्पष्ट वाक्य रचना के रूप में impl<...> Trait जैसा कुछ स्पिटबॉल किया, जो उचित लगता है। इसलिए, कोई लिख सकता है:

fn foo<'a, 'b, T>(...) -> impl<T> Trait { }

यह इंगित करने के लिए कि छुपा प्रकार वास्तव में 'a या 'b को संदर्भित नहीं करता बल्कि केवल T को संदर्भित करता है। या कोई यह इंगित करने के लिए impl<'a> Trait लिख सकता है कि न तो 'b और न ही T पर कब्जा कर लिया गया है।

डिफ़ॉल्ट के लिए, ऐसा लगता है कि अधिक डेटा होना बहुत उपयोगी होगा - लेकिन एलिजन के सामान्य तर्क से पता चलता है कि हम लागू होने पर self के प्रकार में नामित सभी पैरामीटर को कैप्चर करने के लिए अच्छा प्रदर्शन करेंगे। उदाहरण के लिए, यदि आपके पास fn foo<'a,'b>(&'a self, v: &'b [u8]) और प्रकार Bar<'c, X> , तो self का प्रकार &'a Bar<'c, X> और इसलिए हम 'a पर कब्जा करेंगे 'c , और X डिफ़ॉल्ट रूप से, लेकिन 'b ।

एक और संबंधित नोट यह है कि आजीवन बाध्य का अर्थ क्या है। मुझे लगता है कि ध्वनि जीवनकाल सीमाओं का एक मौजूदा अर्थ है जिसे बदला नहीं जाना चाहिए: यदि हम impl (Trait+'a) लिखते हैं तो इसका मतलब है कि छुपा प्रकार T 'a । इसी तरह कोई यह इंगित करने के लिए impl (Trait+'static) लिख सकता है कि कोई उधार संकेत मौजूद नहीं हैं (भले ही कुछ जीवनकाल कैप्चर किए गए हों)। छिपे हुए प्रकार का उल्लेख करते समय T , यह $T: 'static तरह जीवन भर बाध्य होगा, जहां $T वह अनुमान चर है जिसे हम छिपे हुए प्रकार के लिए बनाते हैं। इसे सामान्य तरीके से संभाला जाएगा। एक कॉलर के दृष्टिकोण से, जहां छिपा हुआ प्रकार है, ठीक है, छिपा हुआ है, 'static बाउंड हमें यह निष्कर्ष निकालने की अनुमति देगा कि impl (Trait+'static) 'static जीवित है, भले ही आजीवन पैरामीटर कैप्चर किए गए हों।

यहाँ यह ठीक वैसा ही व्यवहार करता है जैसा कि desugaring व्यवहार करेगा:

fn foo<'a, 'b, T>() -> <() as Foo<'a, 'b, 'T>>::Type { ... }
trait Foo<'a, 'b, T> {
  type Type: Trait + 'static; // <-- note the `'static` bound appears here
}
impl<'a, 'b, T> Foo<...> for () {
  default type Type = /* something that doesn't reference `'a`, `'b`, or `T` */;
}

यह सब अनुमान से ऑर्थोगोनल है। हम अभी भी चाहते हैं (मुझे लगता है) "से चुनें" बाधा की धारणा को जोड़ने के लिए और कुछ अनुमानियों के साथ अनुमान को संशोधित करें और संभवतः, संपूर्ण खोज (आरएफसी 1214 से अनुभव बताता है कि रूढ़िवादी फॉलबैक के साथ हेरिस्टिक वास्तव में हमें बहुत दूर ले जा सकता है; मुझे इस संबंध में सीमाओं में चल रहे लोगों के बारे में पता नहीं है, हालांकि शायद कहीं न कहीं कोई समस्या है)। निश्चित रूप से, 'static या 'a' जैसी आजीवन सीमा जोड़ने से अनुमान प्रभावित हो सकता है, और इस प्रकार सहायक हो सकता है, लेकिन यह एक सही समाधान नहीं है: एक बात के लिए, वे कॉलर को दिखाई देते हैं और API का हिस्सा बन जाते हैं, जो वांछित नहीं हो सकता है।

संभावित विकल्प:

आउटपुट पैरामीटर elision के साथ स्पष्ट जीवनकाल बाध्य

आज की विशेषता वस्तुओं की तरह, impl Trait वस्तुओं में एक आजीवन बाध्य पैरामीटर होता है, जिसका अनुमान elision नियमों का उपयोग करके लगाया जाता है।

नुकसान: अनर्गोनोमिक
लाभ: स्पष्ट

"सभी सामान्य" elision के साथ स्पष्ट जीवनकाल सीमा

आज विशेषता वस्तुओं की तरह, impl Trait वस्तुओं में एक आजीवन बाध्य पैरामीटर होता है।

हालांकि, elision एक नया प्रारंभिक-बाध्य पैरामीटर बनाता है जो सभी स्पष्ट पैरामीटर से अधिक रहता है:

fn foo<T>(&T) -> impl Foo
-->
fn foo<'total, T: 'total>(&T) -> impl Foo + 'total

नुकसान: एक प्रारंभिक-बाध्य पैरामीटर जोड़ता है

अधिक।

मैं इस मुद्दे में निहित विशेषता +'ए और उधार के साथ भाग गया: https://github.com/rust-lang/rust/issues/37790

अगर मैं इस बदलाव को सही ढंग से समझ रहा हूं (और इसकी संभावना शायद कम है!), तो मुझे लगता है कि यह खेल का मैदान कोड काम करना चाहिए:

https://play.rust-lang.org/?gist=496ec05e6fa9d3a761df09c95297aa2a&version=nightly&backtrace=0

ThingOne और ThingTwo Thing विशेषता को लागू करते हैं। build कहना है कि यह कुछ ऐसा लौटाएगा जो Thing लागू करता है, जो यह करता है। फिर भी यह संकलित नहीं करता है। तो मैं स्पष्ट रूप से कुछ गलत समझ रहा हूँ।

उस "कुछ" में एक प्रकार होना चाहिए, लेकिन आपके मामले में आपके पास दो परस्पर विरोधी प्रकार हैं। @nikomatsakis ने पहले इस काम को सामान्य रूप से बनाने का सुझाव दिया है जैसे ThingOne | ThingTwo टाइप बेमेल दिखाई देते हैं।

@eddyb क्या आप ThingOne | ThingTwo पर विस्तार से बता सकते हैं? क्या आपको Box यदि हम केवल रन-टाइम के प्रकार को जानते हैं? या यह एक प्रकार का enum ?

हाँ, यह एक तदर्थ enum जैसा प्रकार हो सकता है जो प्रत्यायोजित विशेषता विधि कॉल, जहां संभव हो, इसके रूपों के लिए।

मैं पहले भी ऐसा कुछ चाहता था। अनाम एनम आरएफसी: https://github.com/rust-lang/rfcs/pull/1154

यह कुछ ऐसा दुर्लभ मामला है जो अनुमान से प्रेरित होने पर बेहतर काम करता है, क्योंकि यदि आप केवल इन प्रकारों को बेमेल पर बनाते हैं, तो वेरिएंट अलग होते हैं (जो सामान्यीकृत रूप में एक समस्या है)।
इसके अलावा आप पैटर्न-मिलान नहीं होने से कुछ प्राप्त कर सकते हैं (स्पष्ट रूप से अलग मामलों को छोड़कर?)
लेकिन आईएमओ प्रतिनिधिमंडल चीनी सभी प्रासंगिक मामलों में "बस काम करेगा", भले ही आप T | T प्राप्त करने का प्रबंधन करें।

क्या आप उन वाक्यों के दूसरे, निहित हिस्सों की व्याख्या कर सकते हैं? मैं इसमें से अधिकांश को नहीं समझता, और मुझे संदेह है कि मुझे कुछ संदर्भ याद आ रहा है। क्या आप संघ के प्रकारों के साथ समस्याओं का स्पष्ट रूप से जवाब दे रहे थे? वह RFC केवल अनाम एनम है, यूनियन प्रकार नहीं - (T|T) बिल्कुल समस्याग्रस्त होगा Result<T, T> ।

ओह, कोई बात नहीं, मुझे प्रस्ताव भ्रमित हो गए (मोबाइल पर तब तक अटका रहा जब तक कि मैं अपने असफल एचडीडी को सुलझा नहीं लेता, इसलिए ट्विटर पर लगने के लिए क्षमा चाहता हूं)।

मुझे लगता है (स्थितिगत, यानी T|U != U|T ) अज्ञात एनम दिलचस्प हैं, और मेरा मानना ​​​​है कि यदि हमारे पास विविध जेनरिक थे (आप hlist का उपयोग करके इसे साइड-स्टेप कर सकते हैं) और मेरा मानना ​​​​है कि उन्हें लाइब्रेरी में प्रयोग किया जा सकता है। कॉन्स्ट जेनरिक (ठीक इसी तरह, पीनो नंबरों के साथ)।

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

मुझे यकीन नहीं है कि यह पूछने के लिए सही जगह है, लेकिन impl जैसे कीवर्ड की आवश्यकता क्यों है? मुझे कोई चर्चा नहीं मिली (मेरी गलती हो सकती है)।

यदि कोई फ़ंक्शन इंप्लांट ट्रैट लौटाता है, तो उसका शरीर किसी भी प्रकार के मान लौटा सकता है जो ट्रैट को लागू करता है

तब से

fn bar(a: &Foo) {
  ...
}

इसका मतलब है "एक प्रकार के संदर्भ को स्वीकार करें जो Foo विशेषता को लागू करता है" मैं उम्मीद करता हूं

fn bar() -> Foo {
  ...
}

इसका मतलब है "एक प्रकार लौटाएं जो विशेषता Foo " लागू करता है। क्या यह असंभव है?

@ kud1 इसका कारण एक फ़ंक्शन होने की संभावना को दूर नहीं करना है जो गतिशील रूप से आकार प्रकार Trait लौटाता है यदि भविष्य में गतिशील रूप से आकार के रिटर्न मानों के लिए समर्थन जोड़ा जाता है। वर्तमान में Trait पहले से ही एक वैध डीएसटी है, एक डीएसटी वापस करना संभव नहीं है इसलिए आपको इसे एक आकार का प्रकार बनाने के लिए इसे बॉक्स करने की आवश्यकता है।

संपादित करें: इसके बारे में लिंक किए गए आरएफसी थ्रेड पर कुछ चर्चा है।

ठीक है, एक के लिए, इस पर ध्यान दिए बिना कि गतिशील रूप से आकार के रिटर्न मान जोड़े जाएंगे, मैं वर्तमान वाक्यविन्यास पसंद करता हूं। विशेषता वस्तुओं के साथ क्या होता है, इसके विपरीत, यह टाइप इरेज़र नहीं है, और कोई भी संयोग जैसे "पैरामीटर f: &Foo कुछ ऐसा लेता है जो Foo को दर्शाता है, जबकि यह कुछ ऐसा देता है जो Foo दर्शाता है " भ्रामक हो सकता है।

मैं आरएफसी चर्चा से इकट्ठा हुआ कि अभी impl एक प्लेसहोल्डर कार्यान्वयन है, और कोई impl बहुत वांछित नहीं है। क्या _not_ के लिए impl विशेषता चाहने का कोई कारण है यदि वापसी मूल्य डीएसटी नहीं है?

मुझे लगता है कि "ऑटो विशेषता रिसाव" को संभालने के लिए वर्तमान निहित तकनीक समस्याग्रस्त है। इसके बजाय हमें एक डीएजी आदेश लागू करना चाहिए ताकि यदि आप एक fn fn foo() -> impl Iterator परिभाषित करते हैं, और आपके पास एक कॉलर fn bar() { ... foo() ... } , तो हमें bar() से पहले foo() टाइप-चेक करना होगा bar() (ताकि हम जान सकें कि छिपा हुआ प्रकार क्या है)। यदि एक चक्र का परिणाम होता है, तो हम एक त्रुटि की रिपोर्ट करेंगे। यह एक रूढ़िवादी रुख है - हम शायद बेहतर कर सकते हैं - लेकिन मुझे लगता है कि वर्तमान तकनीक, जहां हम ऑटो-ट्रेट दायित्वों को एकत्र करते हैं और अंत में उनकी जांच करते हैं, सामान्य रूप से काम नहीं करते हैं। उदाहरण के लिए, यह विशेषज्ञता के साथ अच्छा काम नहीं करेगा।

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

@Nercury मुझे समझ में नहीं आता। क्या आप पूछ रहे हैं कि क्या fn foo() -> Trait का अर्थ -> impl Trait ?

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

अंतर यह है कि impl Trait लौटने वाले फ़ंक्शन हमेशा एक ही प्रकार लौटाते हैं- यह मूल रूप से वापसी प्रकार का अनुमान है। IIUC, केवल Trait लौटने वाले फ़ंक्शन गतिशील रूप से उस विशेषता के किसी भी कार्यान्वयन को वापस करने में सक्षम होंगे, लेकिन कॉल करने वाले को box foo() जैसी किसी चीज़ के माध्यम से वापसी मूल्य के लिए स्थान आवंटित करने के लिए तैयार रहने की आवश्यकता होगी।

@Nercury सरल कारण यह है कि -> Trait सिंटैक्स का पहले से ही एक अर्थ है, इसलिए हमें इस सुविधा के लिए कुछ और उपयोग करना होगा।

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

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

वह केवल एक वापसी प्रकार की अनुमति-नियम को बायपास करेगा।

@NeoLegends इसे मैन्युअल रूप से करना काफी आम है, और इसके लिए कुछ चीनी अच्छी हो सकती है और अतीत में प्रस्तावित की गई है, लेकिन यह impl Trait या एक विशेषता वस्तु को वापस करने से अर्थशास्त्र का तीसरा पूरी तरह से अलग सेट है, इसलिए यह नहीं है इस चर्चा के लिए वास्तव में प्रासंगिक।

@Ixrec हाँ, मुझे पता है कि यह मैन्युअल रूप से किया जा रहा है, लेकिन

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

बेनामी, ऑटो-जेनरेटेड एनम impl Trait एक छिपी हुई लागत देता है जिसे याद करना आसान है, इसलिए यह विचार करने के लिए कुछ है।

मुझे संदेह है कि "ऑटो एनम पास-थ्रू" चीज़ केवल ऑब्जेक्ट-सुरक्षित लक्षणों के लिए समझ में आता है। क्या impl Trait के बारे में भी यही बात सच है?

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

@glaebhoerl

मुझे संदेह है कि "ऑटो एनम पास-थ्रू" चीज़ केवल ऑब्जेक्ट-सुरक्षित लक्षणों के लिए समझ में आता है। क्या इम्प्लांट ट्रैट के बारे में भी यही बात सच है?

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

@nikomatsakis

समस्या है, जंग के संदर्भ में

trait Foo {
    type Output;
    fn get() -> Self::Output;
}

fn foo() -> impl Foo {
    // ...
    // what is the type of return_type::get?
}

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

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

(मुझे यकीन नहीं है कि यह मेरे मूल प्रश्न से संबंधित है या नहीं, impl Trait , और/या स्वचालित एनम पासथ्रू के साथ उपयोग किए जाने वाले लक्षण, आवश्यकता से ऑब्जेक्ट-सुरक्षित होना चाहिए, हालांकि?)

@rpjohnst लागत को चिह्नित करने के लिए

fn foo() -> enum impl Trait { ... }

हालांकि यह लगभग निश्चित रूप से एक अलग आरएफसी के लिए भोजन है।

@glaebhoerl हाँ, मैंने इस मुद्दे को खोदने में कुछ समय बिताया और काफी हद तक आश्वस्त महसूस किया कि कम से कम यहां कोई समस्या नहीं होगी।

क्षमा करें अगर यह कुछ स्पष्ट है, लेकिन मैं उन कारणों को समझने की कोशिश कर रहा हूं कि क्यों impl Trait वापसी प्रकार की विशेषता विधियों में प्रकट नहीं हो सकता है, या क्या यह पहली जगह में समझ में आता है? जैसे:

trait IterInto {
    type Output;
    fn iter_into(&self) -> impl Iterator<Item=impl Into<Self::Output>>;
}

@aldanor यह पूरी तरह से समझ में आता है, और AFAIK का इरादा उस काम को करना है, लेकिन इसे अभी तक लागू नहीं किया गया है।

यह बनाता है की तरह समझ है, लेकिन यह एक ही अंतर्निहित विशेषता (यह एक बहुत btw चर्चा की गई) नहीं है:

// What that trait would desugar into:
trait IterInto {
    type Output;
    type X: Into<Self::Output>;
    type Y: Iterator<Item=Self::X>;
    fn iter_into(&self) -> Self::Y;
}

// What an implementation would desugar into:
impl InterInto for FooList {
    type Output = Foo;
    // These could potentially be left unspecified for
    // a similar effect, if we want to allow that.
    type X = impl Into<Foo>;
    type Y = impl Iterator<Item=Self::X>;
    fn iter_into(&self) -> Self::Y {...}
}

विशेष रूप से, impl Trait में impl Trait for Type संबद्ध प्रकार' RHSes आज लागू की गई सुविधा के समान होंगे, जिसमें इसे स्थिर रस्ट के रूप में नहीं बदला जा सकता है, जबकि trait यह हो सकता है।

मुझे पता है कि यह शायद बहुत देर हो चुकी है, और अधिकतर बाइकशेडिंग है, लेकिन क्या यह कहीं भी दस्तावेज किया गया है कि कीवर्ड impl क्यों पेश किया गया था? यह मुझे ऐसा लगता है जैसे हमारे पास पहले से ही मौजूदा रस्ट कोड में यह कहने का एक तरीका है कि "कंपाइलर यह बताता है कि किस प्रकार का यहाँ जाता है", अर्थात् _ । क्या हम इसे यहाँ सिंटेक्स देने के लिए दोबारा इस्तेमाल नहीं कर सकते हैं:

fn foo() -> _ as Iterator<Item=u8> {}

@jonhoo यह वह नहीं है जो सुविधा करता है, प्रकार वह नहीं है जो फ़ंक्शन से लौटा है, बल्कि एक "अर्थात् आवरण" है जो चुने हुए एपीआई (और OIBITs क्योंकि वे एक दर्द हैं) को छोड़कर सब कुछ छुपाते हैं।

हम कुछ कार्यों को डीएजी को मजबूर करके उनके हस्ताक्षरों में प्रकार का अनुमान लगाने की अनुमति दे सकते हैं, लेकिन ऐसी सुविधा को कभी भी मंजूरी नहीं दी गई है और यह कभी भी जंग में जोड़े जाने की संभावना नहीं है, क्योंकि यह "वैश्विक अनुमान" पर स्पर्श करेगा।

जैसा कि यहां बताया गया है, impl Trait को बदलने के लिए @Trait सिंटैक्स के उपयोग का सुझाव दें।

अन्य प्रकार की स्थितियों और Box<@MyTrait> या &@MyTrait जैसी संरचना में विस्तार करना आसान है।

@Trait लिए any T where T: Trait और ~Trait लिए some T where T: Trait :

fn compose<T, U, V>(f: @Fn(T) -> U, g: @Fn(U) -> V) -> ~Fn(T) -> V {
    move |x| g(f(x))
}

में fn func(t: T) -> V , किसी भी टी या कुछ वी को भेद करने की आवश्यकता नहीं है, इसलिए विशेषता के रूप में।

fn compose<T, U, V>(f: @Fn(T) -> U, g: @Fn(U) -> V) -> @Fn(T) -> V {
    move |x| g(f(x))
}

अभी भी काम करता है।

@ जेएफ-लियू मैं व्यक्तिगत रूप से any और some को एक कीवर्ड/सिगिल में मिलाने का विरोध कर रहा हूं लेकिन आप तकनीकी रूप से सही हैं कि हमारे पास एक सिंगल सिगिल हो सकता है और इसे मूल impl Trait तरह इस्तेमाल कर सकते हैं

@ जेएफ-लियू @eddyb भाषा से सिगिल हटा दिए जाने का एक कारण था। वह कारण इस मामले पर लागू क्यों नहीं होगा?

@ का उपयोग पैटर्न मिलान में भी किया जाता है, भाषा से हटाया नहीं जाता है।

मेरे मन में यह बात थी कि AFAIK सिगिल का अधिक उपयोग किया गया था।

सिंटैक्स बाइकशेडिंग: मैं impl Trait नोटेशन के बारे में गहराई से नाखुश हूं, क्योंकि एक प्रकार का नाम देने के लिए एक कीवर्ड (एक संपादक में बोल्ड फ़ॉन्ट) का उपयोग करना बहुत ज़ोरदार है। C का struct और स्ट्राउस्ट्रौप लाउड सिंटैक्स अवलोकन (स्लाइड 14) याद रखें?

https://internals.rust-lang.org/t/ideas-for-making-rust-easier-for-beginners/4761 में , @konstin ने <Trait> सिंटैक्स का सुझाव दिया। यह वास्तव में अच्छा लग रहा है, खासकर इनपुट स्थितियों में:

fn take_iterator(iterator: <Iterator<Item=i32>>)

मैं देख रहा हूँ कि यह UFCS के साथ कुछ हद तक संघर्ष करेगा, लेकिन शायद इस पर काम किया जा सकता है?

मैं भी बेहतर विकल्प होने के लिए इम्प्लांट विशेषता के बजाय कोण ब्रैकेट का उपयोग महसूस करता हूं, कम से कम वापसी प्रकार की स्थिति में, उदाहरण के लिए:

fn returns_iter() -> <Iterator<Item=i32>> {...}
fn returns_closure() -> <FnOnce() -> bool> {...}

<Trait> सिंटैक्स जेनेरिक के साथ संघर्ष करता है, इस पर विचार करें:

Vec<<FnOnce() -> bool>> बनाम Vec<@FnOnce() -> bool>

यदि Vec<FnOnce() -> bool> की अनुमति है, तो <Trait> अच्छा विचार है, यह सामान्य प्रकार पैरामीटर के समकक्षता को दर्शाता है। लेकिन चूंकि Box<Trait> Box<@Trait> , <Trait> सिंटैक्स को छोड़ना होगा।

मैं impl कीवर्ड सिंटैक्स को प्राथमिकता देता हूं क्योंकि जब आप दस्तावेज़ीकरण को तेज़ी से पढ़ते हैं तो यह प्रोटोटाइप को गलत तरीके से पढ़ने की अनुमति देता है।
तुम क्या सोचते हो ?

मैं सिर्फ यह महसूस कर रहा हूं कि मैंने इस आरएफसी को आंतरिक धागे में एक सुपरसेट का प्रस्ताव दिया था (मुझे यहां इंगित करने के लिए @matklad के लिए धन्यवाद):

फ़ंक्शन पैरामीटर और रिटर्न प्रकारों में लक्षणों को कोण ब्रैकेट के साथ आस-पास उपयोग करने की अनुमति दें जैसे निम्न उदाहरण में:

fn transform(iter: <Iterator>) -> <Iterator> {
    // ...
}

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

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

सिंटैक्स हाइलाइटिंग में एक अलग रंग को चाल चलनी चाहिए।

स्ट्रॉस्ट्रुप का यह पेपर सेक्शन 7 में C++ कॉन्सेप्ट्स के लिए समान सिंटैक्टिक विकल्पों पर चर्चा करता है: http://www.stroustrup.com/good_concepts.pdf

जेनरिक और अस्तित्व के लिए समान सिंटैक्स का उपयोग न करें। ये एक ही चीज नहीं हैं। जेनरिक कॉलर को यह तय करने की अनुमति देता है कि ठोस प्रकार क्या है, जबकि (इस प्रतिबंधित उपसमुच्चय का) अस्तित्व समारोह को यह तय करने की अनुमति देता है कि ठोस प्रकार क्या है। यह उदाहरण:

fn transform(iter: <Iterator>) -> <Iterator>

या तो इसके बराबर होना चाहिए

fn transform<T: Iterator, U: Iterator>(iter: T) -> U

या यह इसके बराबर होना चाहिए

fn transform(iter: impl Iterator) -> impl Iterator

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

हो सकता है कि वाक्य-विन्यास समान होना चाहिए, लेकिन यह समान नहीं होना चाहिए।

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

• ठोस डेटा प्रकारों, स्थिर प्रेषण के लिए Type , &Type , Box<Type>
• @Trait , &@Trait , Box<@Trait> और सार डेटा प्रकार, स्थिर प्रेषण के लिए सामान्य प्रकार पैरामीटर का उपयोग करें
• अमूर्त डेटा प्रकार, गतिशील प्रेषण के लिए &Trait , Box<Trait>

fn func(x: @Trait) fn func<T: Trait>(x: T) बराबर है।
fn func<T1: Trait, T2: Trait>(x: T1, y: T2) को केवल fn func(x: <strong i="22">@Trait</strong>, y: @Trait) रूप में लिखा जा सकता है।
T पैरामीटर को अभी तक की जरूरत है fn func<T: Trait>(x: T, y: T) ।

struct Foo { field: <strong i="28">@Trait</strong> } struct Foo<T: Trait> { field: T } बराबर है।

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

आप मौजूदा जेनेरिक सिंटैक्स का उपयोग करके, स्थिर रस्ट में अभी किसी भी विशेषता को वापस कर सकते हैं। यह बहुत अधिक उपयोग की जाने वाली विशेषता है। serde_json::de::from_slice एक पैरामीटर के रूप में &[u8] serde_json::de::from_slice लेता है और T where T: Deserialize लौटाता है।

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

अधिक परिचित उदाहरण के लिए, Iterator::collect कोई भी T where T: FromIterator<Self::Item> लौटा सकता है, जिसका अर्थ है कि मेरा पसंदीदा नोटेशन: fn collect(self) -> any FromIterator<Self::Item> ।

सिंटैक्स के बारे में कैसे
fn foo () -> _ : Trait { ... }
वापसी मूल्यों के लिए और
fn foo (m: _1, n: _2) -> _ : Trait where _1: Trait1, _2: Trait2 { ... }
मापदंडों के लिए?

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

हाँ, मौजूदा खोजशब्दों के साथ रहना मेरे लिए आदर्श लगता है; मैं अस्तित्व के लिए impl और यूनिवर्सल के लिए for देखना चाहता हूं।

मैं व्यक्तिगत रूप से any और some को एक कीवर्ड/सिगिल में मिलाने का विरोध करता हूं

@eddyb मैं इसे एक मानूंगा । यह नियम से स्वाभाविक रूप से अनुसरण करता है:

((∃ T . F⟨T⟩) → R)  →  ∀ T . (F⟨T⟩ → R)

संपादित करें: यह एकतरफा है, समरूपता नहीं।

असंबंधित: क्या impl Trait को अन्य सहसंयोजक पदों जैसे में भी अनुमति देने के लिए कोई संबंधित प्रस्ताव है

~जंगएफएन फू(कॉलबैक: एफ) -> आरजहाँ F: FnOnce(impl SomeTrait) -> R {कॉलबैक (create_something ())}~

अभी , यह एक आवश्यक विशेषता नहीं है, क्योंकि आप हमेशा impl SomeTrait लिए एक ठोस समय लगा सकते हैं, जो पठनीयता को नुकसान पहुंचाता है लेकिन अन्यथा कोई बड़ी बात नहीं है।

लेकिन अगर RFC 1522 फीचर स्थिर हो जाता है, तो उपरोक्त कार्यक्रमों के लिए एक टाइप सिग्नेचर असाइन करना असंभव होगा यदि create_something परिणाम impl SomeTrait (कम से कम बॉक्सिंग के बिना) हो। मुझे लगता है कि यह समस्याग्रस्त है।

@Rufflewind वास्तविक दुनिया में, चीजें इतनी स्पष्ट नहीं हैं, और यह सुविधा अस्तित्व का एक बहुत ही विशिष्ट ब्रांड है (जंग में अब तक कई हैं)।

लेकिन फिर भी, आपके पास केवल यह निर्धारित करने के लिए कॉन्वर्सिस का उपयोग होता है कि impl Trait अर्थ फ़ंक्शन तर्कों के अंदर और बाहर क्या है।

इसके लिए पर्याप्त नहीं है:

• डिफ़ॉल्ट के विपरीत का उपयोग करना
• किसी फ़ील्ड के प्रकार के अंदर स्पष्ट करना (जहां any और some दोनों समान रूप से वांछनीय हैं)

@Rufflewind जो impl Trait लिए गलत ब्रैकेटिंग जैसा लगता है। मुझे पता है कि हास्केल सार्वभौमिक और अस्तित्व दोनों का प्रतिनिधित्व करने के लिए केवल forall कीवर्ड का उपयोग करने के लिए इस संबंध का फायदा उठाता है, लेकिन यह उस संदर्भ में काम नहीं करता है जिस पर हम चर्चा कर रहे हैं।

इस परिभाषा को लें, उदाहरण के लिए:

fn foo(x: impl ArgTrait) -> impl ReturnTrait { ... }

यदि हम इस नियम का उपयोग करते हैं कि " impl तर्कों में सार्वभौमिक है, impl रिटर्न प्रकारों में अस्तित्वगत है", तो foo फ़ंक्शन आइटम प्रकार का प्रकार तार्किक रूप से यह है (में मेड-अप टाइप नोटेशन):

forall<T: ArgTrait>(exists<R: ReturnTrait>(fn(T) -> R))

भोलेपन से impl को तकनीकी रूप से केवल सार्वभौमिक या केवल अस्तित्वगत अर्थ के रूप में मानना ​​​​और तर्क को स्वयं काम करने देना वास्तव में काम नहीं करता है। आपको या तो यह मिलेगा:

forall<T: ArgTrait, R: ReturnTrait>(fn(T) -> R)

या यह:

exists<T: ArgTrait, R: ReturnTrait>(fn(T) -> R)

और इनमें से कोई भी तार्किक नियमों द्वारा हम जो चाहते हैं उसे कम नहीं करते हैं। तो अंततः any / some एक महत्वपूर्ण अंतर को कैप्चर करते हैं जिसे आप एक कीवर्ड के साथ कैप्चर नहीं कर सकते हैं। std में भी उचित उदाहरण हैं जहां आप वापसी की स्थिति में सार्वभौमिक चाहते हैं। उदाहरण के लिए, यह Iterator विधि:

fn collect<B>(self) -> B where B: FromIterator<Self::Item>;
// is equivalent to
fn collect(self) -> any FromIterator<Self::Item>;

और इसे impl और तर्क/वापसी नियम के साथ लिखने का कोई तरीका नहीं है।

tl; dr होने के impl प्रासंगिक रूप से या तो सार्वभौमिक या अस्तित्वगत रूप से निरूपित करते हैं, वास्तव में इसे दो अलग-अलग अर्थ देते हैं।

संदर्भ के लिए, मेरे नोटेशन में फोरऑल/अस्तित्व संबंध @ रफलविंड का उल्लेख इस तरह दिखता है:

fn(exists<T: Trait>(T)) -> R === forall<T: Trait>(fn(T) -> R)

जो जेनेरिक (सार्वभौमिक) के बराबर होने वाली विशेषता वस्तुओं (अस्तित्व) की अवधारणा से संबंधित है, लेकिन इस impl Trait प्रश्न से नहीं।

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

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

संक्षेप में, मुझे इससे खुशी होगी:

• impl Trait दोनों सार्वभौमिक और अस्तित्व (प्रासंगिक रूप से) के लिए आशुलिपि के रूप में।
• सार्वभौमिक और अस्तित्व दोनों के लिए पूरी तरह से सामान्य लॉन्गहैंड के रूप में नामित प्रकार के पैरामीटर। (कम सामान्यतः आवश्यक।)

भोलेपन से impl को तकनीकी रूप से केवल सार्वभौमिक या केवल अस्तित्वगत अर्थ के रूप में मानना ​​​​और तर्क को स्वयं ही काम करने देना वास्तव में काम नहीं करता है। आपको या तो यह मिलेगा:

@solson मेरे लिए, एक " ठीक बगल में मौजूद क्वांटिफायर में

~जंग(इम्प्ल मायट्रेट)~

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

~जंग(मौजूदटी)~

जो एक साधारण स्थानीय परिवर्तन है। इस प्रकार, " impl का पालन करने वाला एक भोला अनुवाद हमेशा एक अस्तित्वगत होता है" नियम का परिणाम होगा:

~जंगएफएन(मौजूद हैटी) -> (मौजूदआर)~

फिर, यदि आप क्वांटिफायर को फ़ंक्शन तर्क से बाहर निकालते हैं, तो यह बन जाता है

~जंगके लियेएफएन (टी) -> (मौजूद हैआर)~

तो भले ही T हमेशा स्वयं के सापेक्ष अस्तित्वगत होता है, यह पूरे फ़ंक्शन प्रकार के लिए सार्वभौमिक सापेक्ष के रूप में प्रकट होता है।

आईएमओ, मुझे लगता है कि impl अस्तित्वगत प्रकारों के लिए वास्तविक वास्तविक कीवर्ड भी बन सकता है। भविष्य में, शायद कोई और अधिक जटिल अस्तित्वगत प्रकारों का निर्माण कर सकता है जैसे:

~~जंग(प्रत्यक्ष(Vec, टी))~ ~

सार्वभौमिक प्रकारों के अनुरूप (एचआरटीबी के माध्यम से)

~जंग(<'a> FnOnce(&'a T) के लिए)~

@Rufflewind वह दृश्य काम नहीं करता क्योंकि fn(T) -> (exists<R: ReturnTrait>(R)) तार्किक रूप से exists<R: ReturnTrait>(fn(T) -> R) बराबर नहीं है, जो कि वापसी-प्रकार impl Trait वास्तव में अर्थ है।

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

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

@solson हाँ आप सही हैं: अस्तित्व को

(T → ∃R. f(R))  ⥇  ∃R. T → f(R)

जबकि ये सामान्य रूप से धारण करते हैं:

(∃R. T → f(R))  →   T → ∃R. f(R)
(∀A. g(A) → T)  ↔  ((∃A. g(A)) → T)

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

संपादित करें: ओह, (∀A. g(A) → T) → (∃A. g(A)) → T धारण करता है।

मैंने impl Trait को विस्तारित और स्थिर करने के विस्तृत प्रस्ताव के साथ एक RFC पोस्ट किया है। यह इस और पहले के धागों पर बहुत सारी चर्चाओं पर आधारित है।

ध्यान देने योग्य बात यह है कि https://github.com/rust-lang/rfcs/pull/1951 को स्वीकार कर लिया गया है।

इस पर अभी क्या स्थिति है? हमारे पास एक आरएफसी है जो उतरा है, हमारे पास प्रारंभिक कार्यान्वयन का उपयोग करने वाले लोग हैं, लेकिन मैं स्पष्ट नहीं हूं कि कौन से आइटम टूडू हैं।

यह #43869 में पाया गया कि -> impl Trait फ़ंक्शन पूरी तरह से अलग होने वाले शरीर का समर्थन नहीं करता है:

fn do_it_later_but_cannot() -> impl Iterator<Item=u8> { //~ ERROR E0227
    unimplemented!()
}

क्या यह अपेक्षित है (चूंकि ! अर्थ Iterator ), या इसे एक बग माना जाता है?

अनुमानित प्रकारों को परिभाषित करने के बारे में क्या है, जिसका उपयोग न केवल वापसी मूल्यों के रूप में किया जा सकता है, बल्कि कुछ भी (मुझे लगता है) वर्तमान में एक प्रकार का उपयोग किया जा सकता है?
कुछ इस तरह:
type Foo: FnOnce() -> f32 = #[infer];
या एक कीवर्ड के साथ:
infer Foo: FnOnce() -> f32;

प्रकार Foo उपयोग रिटर्न प्रकार, पैरामीटर प्रकार या किसी अन्य प्रकार के लिए उपयोग किया जा सकता है, लेकिन दो अलग-अलग स्थानों पर इसका उपयोग करना अवैध होगा, जिसके लिए एक अलग प्रकार की आवश्यकता होती है, भले ही वह प्रकार दोनों ही मामलों में FnOnce() -> f32 लागू करता है। उदाहरण के लिए, निम्नलिखित संकलित नहीं होगा:

infer Foo: FnOnce() -> f32;

fn return_closure() -> Foo {
    || 0.1
}

fn return_closure2() -> Foo {
    || 0.2
}

fn main() {
    println!("{:?}, {:?}", return_closure()(), return_closure2()());
}

यह संकलन नहीं करना चाहिए क्योंकि भले से वापसी प्रकार यद्यपि return_closure और return_closure2 दोनों FnOnce() -> f32 , उनके प्रकार, वास्तव में अलग हैं, क्योंकि कोई दो बंदी जंग में एक ही प्रकार है . उपरोक्त को संकलित करने के लिए आपको दो अलग-अलग अनुमानित प्रकारों को परिभाषित करने की आवश्यकता होगी:

infer Foo: FnOnce() -> f32;
infer Foo2: FnOnce() -> f32; //Added this line

fn return_closure() -> Foo {
    || 0.1
}

fn return_closure2() -> Foo2 { //Changed Foo to Foo2
    || 0.2
}

fn main() {
    println!("{:?}, {:?}", return_closure()(), return_closure2()());
}

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

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

@alvitawa देखें https://github.com/rust-lang/rfcs/pull/2071

@cramertj आह तो इसलिए यह मुद्दा इतना खामोश हो गया था ..

तो, @cramertj मुझसे इस बारे में पूछ रहे थे कि मैंने कैसे सोचा कि देर से आने वाले क्षेत्रों की समस्या को हल करना सबसे अच्छा होगा जो उन्होंने अपने पीआर में सामना किया था। मेरा मानना ​​है कि हम शायद अपने कार्यान्वयन को "रीटूल" करना चाहते हैं और anonymous type Foo मॉडल की प्रतीक्षा कर रहे हैं।

संदर्भ के लिए, विचार मोटे तौर पर यह है कि

fn foo<'a, 'b, T, U>() -> impl Debug + 'a

होगा (तरह का) इस तरह कुछ करने के लिए desugared

anonymous type Foo<'a, T, U>: Debug + 'a
fn foo<'a, 'b, T, U>() -> Foo<'a, T, U>

ध्यान दें कि इस फॉर्म में, आप देख सकते हैं कि कौन से सामान्य पैरामीटर कैप्चर किए गए हैं क्योंकि वे Foo तर्क के रूप में प्रकट होते हैं - विशेष रूप से, 'b पर कब्जा नहीं किया जाता है, क्योंकि यह विशेषता संदर्भ में प्रकट नहीं होता है किसी भी तरह से, लेकिन प्रकार पैरामीटर T और U हमेशा होते हैं।

वैसे भी, वर्तमान में कंपाइलर में, जब आपके पास impl Debug संदर्भ होता है, तो हम एक def-id बनाते हैं जो - प्रभावी रूप से - इस अनाम प्रकार का प्रतिनिधित्व करता है। फिर हमारे पास generics_of क्वेरी है, जो इसके सामान्य मापदंडों की गणना करती है। अभी, यह "संलग्न" संदर्भ के समान है - अर्थात, फ़ंक्शन foo । यही हम बदलना चाहते हैं।

"दूसरी तरफ", यानी foo के हस्ताक्षर में, हम impl Foo को TyAnon । यह मूल रूप से सही है - TyAnon Foo के संदर्भ का प्रतिनिधित्व करता है जिसे हम उपरोक्त desugaring में देखते हैं। लेकिन जिस तरह से हम इस प्रकार के लिए "सबस्ट्स" प्राप्त करते हैं, वह "पहचान" फ़ंक्शन का उपयोग करना है , जो स्पष्ट रूप से गलत है - या कम से कम सामान्यीकरण नहीं करता है।

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

मुझे लगता है कि हमें जो करना चाहिए वह कुछ ऐसा है:

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

मुझे लगता है कि हम जो करना चाहते हैं वह उन क्षेत्रों के समूह को जमा कर रहा है जो दिखाई देते हैं और उन्हें किसी क्रम में रखते हैं, और उन क्षेत्रों के मूल्यों को foo() दृष्टिकोण से ट्रैक FreeRegion की धारणा हुआ करती FreeRegion उपयोग नहीं करते हैं, केवल देर से आने वाली सामग्री के लिए।)

शायद सबसे आसान और सबसे अच्छा विकल्प सिर्फ एक Region<'tcx> उपयोग करना होगा, लेकिन जब आप किसी भी बाइंडर को "रद्द करें" पर जाते हैं तो आपको debruijn अनुक्रमणिका गहराई को स्थानांतरित करना होगा। हालांकि यह शायद सबसे अच्छा विकल्प है।

इसलिए मूल रूप से जैसे ही हमें visit_lifetime में कॉलबैक मिलते हैं, हम उन्हें प्रारंभिक गहराई में व्यक्त Region<'tcx> में बदल देंगे (जैसे ही हम बाइंडर्स से गुजरते हैं, हमें ट्रैक करना होगा)। हम डुप्लिकेट को हटाते हुए उन्हें एक वेक्टर में जमा कर देंगे।

जब हम काम पूरा कर लेते हैं, तो हमारे पास दो चीज़ें होती हैं:

• सबसे पहले, वेक्टर में प्रत्येक क्षेत्र के लिए, हमें एक सामान्य क्षेत्र पैरामीटर बनाना होगा। उन सभी के गुमनाम नाम हो सकते हैं या जो भी हो, इससे कोई खास फर्क नहीं पड़ता (हालांकि शायद हमें उन्हें def-id या कुछ और चाहिए...? मुझे RegionParameterDef डेटा संरचनाओं को देखना होगा...) .
• दूसरा, वेक्टर में क्षेत्र भी वे चीजें हैं जिन्हें हम "पदार्थ" के लिए उपयोग करना चाहते हैं।

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

@nikomatsakis मेरा मानना ​​​​है कि इसमें से बहुत कुछ वैसा ही है जैसा मैंने @cramertj को बताया है, लेकिन अधिक

मैं अस्तित्वगत impl Trait बारे में सोच रहा था और मुझे एक जिज्ञासु मामले का सामना करना पड़ा जहां मुझे लगता है कि हमें सावधानी से आगे बढ़ना चाहिए। इस समारोह पर विचार करें:

trait Foo<T> { }
impl Foo<()> for () { }
fn foo() -> impl Foo<impl Debug> {
  ()
}

जैसा कि आप play पर मान्य कर सकते

विशेष रूप से, यह स्पष्ट है कि हम उस प्रकार को कैसे निकालते हैं जो यहां लौटाया जा रहा है ( () )। यह कम स्पष्ट है कि हम impl Debug पैरामीटर के प्रकार को कैसे निकालते हैं। यही है, आप इस वापसी मूल्य के बारे में सोच सकते हैं जैसे -> ?T जहां ?T: Foo<?U> । हमें ?T और ?U के मूल्यों को केवल इस तथ्य के आधार पर निकालना होगा कि ?T = () ।

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

यह रस्ट में बहुत सारे परिदृश्यों में हो सकता है - जो पर्याप्त से संबंधित है, लेकिन ऑर्थोगोनल है - लेकिन impl Trait मामले के बारे में कुछ अलग है। impl Trait के मामले में, हमारे पास अनुमान के साथ मार्गदर्शन करने के लिए उपयोगकर्ता के प्रकार एनोटेशन जोड़ने का कोई तरीका नहीं है! न ही हमारे पास वास्तव में इस तरह की कोई योजना है। एकमात्र समाधान fn इंटरफ़ेस को impl Foo<()> या कुछ और स्पष्ट में बदलना है।

भविष्य में, abstract type का उपयोग करके, कोई कल्पना कर सकता है कि उपयोगकर्ता स्पष्ट रूप से छिपे हुए मूल्य (या शायद केवल अपूर्ण संकेत, _ का उपयोग करके) दे सकते हैं, जो तब अनुमान लगाने में मदद कर सकता है, जबकि मोटे तौर पर एक ही सार्वजनिक इंटरफ़ेस

abstract type X: Debug = ();
fn foo() -> impl Foo<X> {
  ()
}

फिर भी, मुझे लगता है कि संबंधित प्रकार की बाइंडिंग (उदाहरण के लिए, impl Iterator<Item = impl Debug> इन अस्पष्टताओं से ग्रस्त नहीं है) को छोड़कर, अस्तित्वपरक प्रभाव विशेषता के "नेस्टेड" उपयोगों को स्थिर करने से बचना समझदारी होगी।

इम्प्लांट ट्रैट के मामले में, हमारे पास अनुमान के साथ मार्गदर्शन करने के लिए उपयोगकर्ता के प्रकार एनोटेशन जोड़ने का कोई तरीका नहीं है! न ही हमारे पास वास्तव में इस तरह की कोई योजना है।

शायद यह UFCS जैसा दिख सकता है? उदाहरण के लिए <() as Foo<()>> -- नंगे as जैसे प्रकार को नहीं बदलना , बस इसे असंबद्ध करना। यह वर्तमान में अमान्य सिंटैक्स है क्योंकि यह :: और अधिक अनुसरण करने की अपेक्षा करता है।

मुझे Fn लिए impl Trait के साथ प्रकार अनुमान के संबंध में एक दिलचस्प मामला मिला:
निम्नलिखित कोड ठीक संकलित करता है :

fn op(s: &str) -> impl Fn(i32, i32) -> i32 {
    match s {
        "+" => ::std::ops::Add::add,
        "-" => ::std::ops::Sub::sub,
        "<" => |a,b| (a < b) as i32,
        _ => unimplemented!(),
    }
}

यदि हम उप-पंक्ति पर टिप्पणी करते हैं, तो एक संकलन त्रुटि उत्पन्न होती है :

error[E0308]: match arms have incompatible types
 --> src/main.rs:4:5
  |
4 | /     match s {
5 | |         "+" => ::std::ops::Add::add,
6 | | //         "-" => ::std::ops::Sub::sub,
7 | |         "<" => |a,b| (a < b) as i32,
8 | |         _ => unimplemented!(),
9 | |     }
  | |_____^ expected fn item, found closure
  |
  = note: expected type `fn(_, _) -> <_ as std::ops::Add<_>>::Output {<_ as std::ops::Add<_>>::add}`
             found type `[closure@src/main.rs:7:16: 7:36]`
note: match arm with an incompatible type
 --> src/main.rs:7:16
  |
7 |         "<" => |a,b| (a < b) as i32,
  |                ^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error

@oberien यह impl Trait से संबंधित प्रतीत नहीं होता है - यह सामान्य रूप से अनुमान के बारे में सच है। अपने उदाहरण के इस मामूली संशोधन का प्रयास करें:

fn main() {
    let _: i32 = (match "" {
        "+" => ::std::ops::Add::add,
        //"-" => ::std::ops::Sub::sub,
        "<" => |a,b| (a < b) as i32,
        _ => unimplemented!(),
    })(5, 5);
}

ऐसा लगता है कि यह अब बंद हो गया है:

एलिसन के साथ बातचीत करते समय आईसीई

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

struct Counter(impl Generator<Yield=i32, Return=!>);

impl Counter {
    fn new() -> Counter {
        Counter(|| {
            let mut x: i32 = 0;
            loop {
                yield x;
                x += 1;
            }
        })
    }
}

impl Trait ऐसा करने का सही तरीका नहीं हो सकता है - शायद अमूर्त प्रकार, अगर मैंने RFC 2071 को सही ढंग से पढ़ा और समझा है। हमें जो चाहिए वह कुछ ऐसा है जिसे हम संरचना परिभाषा में लिख सकते हैं ताकि वास्तविक प्रकार ( [generator@src/main.rs:15:17: 21:10 _] ) का अनुमान लगाया जा सके।

@mikeyhew अमूर्त प्रकार वास्तव में जिस तरह से हम उम्मीद करते हैं कि काम करने के लिए, मुझे विश्वास है। वाक्यविन्यास मोटे तौर पर जैसा दिखेगा

abstract type MyGenerator: Generator<Yield = i32, Return = !>;

pub struct Counter(MyGenerator);

impl Counter {
    pub fn new() -> Counter {
        Counter(|| {
            let mut x: i32 = 0;
            loop {
                yield x;
                x += 1;
            }
        })
    }
}

क्या कोई फ़ॉलबैक पथ है यदि यह किसी और का impl Generator जिसे मैं अपनी संरचना में रखना चाहता हूं, लेकिन उन्होंने मेरे उपयोग के लिए abstract type बनाया?

@scottmcm आप अभी भी अपना खुद का abstract type घोषित कर सकते हैं:

// library crate:
fn foo() -> impl Generator<Yield = i32, Return = !> { ... }

// your crate:
abstract type MyGenerator: Generator<Yield = i32, Return = !>;

pub struct Counter(MyGenerator);

impl Counter {
    pub fn new() -> Counter {
        let inner: MyGenerator = foo();
        Counter(inner)
    }
}

@cramertj रुको, अमूर्त प्रकार पहले से ही रात में हैं ?! पीआर कहां है?

@alexreg नहीं, वे नहीं हैं।

संपादित करें: नमस्ते, भविष्य के आगंतुक! नीचे दी गई समस्या का

मैं उपयोग के इस भयानक किनारे के मामले पर ध्यान आकर्षित करना चाहता हूं जो #47348 . में दिखाई देता है

use ::std::ops::Sub;

fn test(foo: impl Sub) -> <impl Sub as Sub>::Output { foo - foo }

क्या इस तरह impl Trait पर प्रोजेक्शन लौटाने की भी अनुमति दी जानी चाहिए? (क्योंकि वर्तमान में, __यह है।__)

मुझे इस तरह के उपयोग के बारे में कोई चर्चा नहीं मिली, और न ही मुझे इसके लिए कोई परीक्षण केस मिला।

@ExpHP हम्म। यह समस्याग्रस्त प्रतीत होता है, इसी कारण से impl Foo<impl Bar> समस्याग्रस्त है। मूल रूप से, हमारे पास प्रश्न के प्रकार पर कोई वास्तविक बाधा नहीं है - केवल इससे निकलने वाली चीजों पर।

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

https://github.com/rust-lang/rust/blob/a0dcecff90c45ad5d4eb60859e22bb3f1b03842a/src/librustc_typeck/constrained_type_params.rs#L89 -L93

चेकबॉक्स पसंद करने वाले लोगों के लिए ट्राइएज का एक छोटा सा हिस्सा:

• #46464 हो गया -> चेकबॉक्स
• #48072 हो गया -> चेकबॉक्स

@rfcbot fcp मर्ज

मेरा प्रस्ताव है कि हम conservative_impl_trait और universal_impl_trait सुविधाओं को एक लंबित परिवर्तन (https://github.com/rust-lang/rust/issues/46541) के लिए एक सुधार के साथ स्थिर करें।

परीक्षण जो वर्तमान शब्दार्थ का दस्तावेजीकरण करते हैं

इन सुविधाओं के लिए परीक्षण निम्नलिखित निर्देशिकाओं में पाए जा सकते हैं:

रन-पास/इम्प्ल-ट्रेट
ui/impl-विशेषता
संकलन-असफल/निहित-विशेषता

कार्यान्वयन के दौरान हल किए गए प्रश्न

impl Trait की पार्सिंग का विवरण RFC 2250 में हल किया https://github.com/rust-lang/rust/pull/45294 में लागू किया गया

अस्पष्टता को रोकने के लिए impl Trait को नेस्टेड-गैर-संबद्ध-प्रकार की स्थिति और कुछ योग्य पथ स्थितियों से प्रतिबंधित कर दिया गया है। इसे https://github.com/rust-lang/rust/pull/48084 में लागू किया गया था

शेष अस्थिर विशेषताएं

इस स्थिरीकरण के बाद, impl Trait को तर्क स्थिति और गैर-विशेषता कार्यों की वापसी स्थिति में उपयोग करना संभव होगा। हालांकि, impl Trait कहीं भी Fn सिंटैक्स के उपयोग की अभी भी अनुमति नहीं है ताकि भविष्य के डिज़ाइन पुनरावृत्ति की अनुमति मिल सके। इसके अतिरिक्त, तर्क स्थिति में impl Trait का उपयोग करने वाले फ़ंक्शंस के प्रकार पैरामीटर को मैन्युअल रूप से निर्दिष्ट करने की अनुमति नहीं है।

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

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

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

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

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

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

उस मामले के लिए, विशेषता कार्यों में impl Trait तर्क/वापसी स्थिति में, या Fn वाक्यविन्यास में उपयोग करने की स्थिति क्या है ?

@alexreg वापसी-स्थिति impl Trait लक्षणों में एक RFC पर अवरुद्ध है, हालांकि RFC 2071 एक बार लागू होने के बाद समान कार्यक्षमता की अनुमति देगा। तर्क-स्थिति impl Trait लक्षणों में किसी भी तकनीकी विशेषता पर अवरुद्ध नहीं है, जिसके बारे में मुझे पता है, लेकिन RFC में इसकी स्पष्ट रूप से अनुमति नहीं थी, इसलिए इसे कुछ समय के लिए छोड़ दिया गया है।

impl Trait की तर्क स्थिति में Fn सिंटैक्स को टाइप-लेवल HRTB पर ब्लॉक किया गया है, क्योंकि कुछ लोगों को लगता है कि T: Fn(impl Trait) को T: for<X: Trait> Fn(X) डिसुगर करना चाहिए। impl Trait की वापसी की स्थिति में Fn सिंटैक्स किसी भी तकनीकी कारण से अवरुद्ध नहीं है जिसके बारे में मुझे पता है, लेकिन आरएफसी में आगे के डिजाइन कार्य लंबित होने पर इसे अस्वीकार कर दिया गया था-- मैं उम्मीद करता हूं एक और आरएफसी देखें या कम से कम एक अलग FCP इसे स्थिर करने से पहले।

@cramertj ठीक है, अपडेट के लिए धन्यवाद। उम्मीद है कि हम इन दो विशेषताओं को देख सकते हैं जो किसी भी चीज़ पर अवरुद्ध नहीं हैं, कुछ चर्चा के बाद जल्द ही आगे बढ़ें। Desugaring समझ में आता है, तर्क स्थिति में, एक तर्क foo: T जहां T: Trait बराबर है foo: impl Trait , जब तक कि मैं गलत नहीं हूं।

चिंता: https://github.com/rust-lang/rust/issues/34511#issuecomment -322340401 अभी भी वही है। क्या निम्नलिखित की अनुमति देना संभव है?

fn do_it_later_but_cannot() -> impl Iterator<Item=u8> { //~ ERROR E0227
    unimplemented!()
}

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

टर्बोफिश प्रश्न केवल आधा हल किया गया है। हमें कम से कम impl Trait पर प्रभावी रूप से सार्वजनिक कार्यों के तर्कों में चेतावनी देनी चाहिए, impl Trait तर्कों में सार्वजनिक जांच में नए विचार करना चाहिए ।

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

प्रेरणा स्पष्ट जेनेरिक से impl Trait तर्क को बदलकर उपयोगकर्ताओं की टर्बोफिश को तोड़ने से रोकने के लिए है।

मुझे उम्मीद है कि जब ऐसा होने लगेगा और लोग लैंग-टीम की शिकायत करना शुरू कर देंगे, जो वर्तमान में संदेह में हैं, वे आश्वस्त होंगे कि impl Trait को टर्बोफिश के साथ स्पष्ट रूप से आपूर्ति प्रकार के तर्कों का समर्थन करना चाहिए।

@leodasvacas

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

मैं असहमत हूं- इसे हल कर लिया गया है। हम फिलहाल के लिए इन कार्यों के लिए टर्बोफिश को पूरी तरह से अस्वीकार कर रहे हैं। स्पष्ट सामान्य मापदंडों के बजाय impl Trait का उपयोग करने के लिए किसी सार्वजनिक फ़ंक्शन के हस्ताक्षर को बदलना एक महत्वपूर्ण परिवर्तन है।

यदि हम भविष्य में इन कार्यों के लिए टर्बोफिश की अनुमति देते हैं, तो यह संभवतः केवल गैर- impl Trait प्रकार के मापदंडों को निर्दिष्ट करने की अनुमति देगा।

:घंटी: उपरोक्त समीक्षा के अनुसार, यह अब अपनी अंतिम टिप्पणी अवधि में प्रवेश कर रहा है । घंटी:

मुझे यह जोड़ना चाहिए कि मैं https://github.com/rust-lang/rust/pull/49041 भूमि तक स्थिर नहीं होना चाहता। (लेकिन उम्मीद है कि यह जल्द ही होगा।)

तो #49041 में #46541 के लिए एक फिक्स है, लेकिन उस फिक्स का मेरे अनुमान से अधिक प्रभाव है - उदाहरण के लिए, कंपाइलर अब बूटस्ट्रैप नहीं करता है - और यह मुझे यहां सही पाठ्यक्रम के बारे में कुछ विराम दे रहा है। #49041 में समस्या यह है कि हम गलती से जीवन भर को लीक होने दे सकते हैं जो हमें नहीं करना चाहिए था। यहां बताया गया है कि यह कंपाइलर में कैसे प्रकट होता है। हमारे पास इस तरह की एक विधि हो सकती है:

impl TyCtxt<'cx, 'gcx, 'tcx>
where 'gcx: 'tcx, 'tcx: 'cx
{
    fn foos(self) -> impl Iterator<Item = &'tcx Foo> + 'cx {
        /* returns some type `Baz<'cx, 'gcx, 'tcx>` that captures self */
    }
}

यहां महत्वपूर्ण बात यह है कि TyCtxt अपरिवर्तनीय w/r/t 'tcx और 'gcx , इसलिए उन्हें रिटर्न प्रकार में दिखना चाहिए । और फिर भी केवल 'cx और 'tcx निहित विशेषता सीमा में दिखाई देते हैं, इसलिए केवल उन दो जीवनकालों को "कब्जा" किया जाना चाहिए। पुराना संकलक इसे स्वीकार कर रहा था क्योंकि 'gcx: 'cx , लेकिन यह वास्तव में सही नहीं है यदि आप हमारे मन में मौजूद डिसुगरिंग के बारे में सोचते हैं। वह desugaring इस तरह एक अमूर्त प्रकार तैयार करेगा:

abstract type Foos<'cx, 'tcx>: Iterator<Item = &'tcx Foo> + 'cx;

और फिर भी इस अमूर्त प्रकार का मूल्य Baz<'cx, 'gcx, 'tcx> - लेकिन 'gcx दायरे में नहीं है!

यहां समाधान यह है कि हमें सीमा में 'gcx नाम देना होगा। ऐसा करना कष्टप्रद है; हम 'cx + 'gcx उपयोग नहीं कर सकते। हम मान सकते हैं कि एक डमी विशेषता है:

trait Captures<'a> { }
impl<T: ?Sized> Captures<'a> for T { }

और फिर कुछ इस तरह वापस करें impl Iterator<Item = &'tcx Foo> + Captures<'gcx> + Captures<'cx> ।

कुछ मैं नोट करना भूल गया: यदि घोषित वापसी प्रकार dyn Iterator<Item = &'tcx Foo> + 'cx , तो यह ठीक रहेगा, क्योंकि dyn प्रकार जीवनकाल मिटाने की उम्मीद है। इसलिए मुझे विश्वास नहीं किसी भी कारण सीमित यहां संभव है, यह मानते हुए आप के साथ कुछ भी समस्याग्रस्त नहीं कर सकते एक impl Trait है कि एक साथ संभव नहीं होगा dyn Trait ।

कोई इस विचार की अस्पष्ट कल्पना कर सकता है कि अमूर्त प्रकार का मूल्य एक समान अस्तित्वगत है: exists<'gcx> Baz<'cx, 'gcx, 'tcx> ।

हालांकि मुझे लगता है कि एक रूढ़िवादी उपसमुच्चय (जो ऊपर fns को नियंत्रित करता है) को स्थिर करना और बाद में संभावित विस्तार के रूप में इसे फिर से देखना ठीक है, एक बार हमने यह तय कर लिया कि हम इसके बारे में कैसे सोचना चाहते हैं।

अद्यतन: dyn लक्षणों के बारे में मेरे अर्थ को स्पष्ट करने के लिए: मैं कह रहा हूं कि वे 'gcx जैसे जीवन भर को "छिपा" सकते हैं जब तक कि बाध्य ( 'cx , यहां) सुनिश्चित करता है कि जहां भी dyn Trait का उपयोग किया जाएगा, वहां 'gcx अभी भी लाइव रहेगा।

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

Captures विशेषता इस स्थिति के लिए एक अच्छा, हल्का तरीका लगता है। ऐसा लगता है कि यह इस समय अस्थिर के रूप में std::marker में जा सकता है?

@nikomatsakis आपकी अनुवर्ती टिप्पणी ने मुझे महसूस किया कि मैंने यह समझने के लिए यहां सभी टुकड़ों को एक साथ नहीं रखा था कि आप इस मामले में 'gcx को खत्म करने की उम्मीद क्यों कर सकते हैं, यानी 'gcx एक नहीं है ग्राहक के दृष्टिकोण से "प्रासंगिक जीवनकाल"। किसी भी मामले में, रूढ़िवादी शुरू करना ठीक लगता है।

मेरी व्यक्तिगत राय यह है कि https://github.com/rust-lang/rust/issues/46541 वास्तव में कोई बग नहीं है-- यह वह व्यवहार है जिसकी मैं अपेक्षा करता हूं, मैं नहीं देखता कि इसे कैसे अस्वस्थ बनाया जा सकता है, और यह काम करने के लिए एक दर्द है। आईएमओ एक प्रकार को वापस करना संभव होना चाहिए जो Trait और जीवनकाल 'a को impl Trait + 'a में रखता है, इससे कोई फर्क नहीं पड़ता कि इसमें अन्य जीवनकाल क्या हैं। हालांकि, मैं शुरू करने के लिए एक अधिक रूढ़िवादी दृष्टिकोण को स्थिर करने के साथ ठीक हूं अगर वह @ जंग-लैंग/लैंग पसंद करता है।

(स्पष्ट करने के लिए एक और बात: #49041 में फिक्स के साथ केवल एक बार आपको त्रुटियां मिलेंगी, जब छुपा प्रकार लापता जीवनकाल के संबंध में अपरिवर्तनीय है 'gcx , इसलिए यह शायद अपेक्षाकृत कम ही हमला करता है।)

@cramertj

मेरी निजी राय है कि #46541 वास्तव में कोई बग नहीं है-- यह वह व्यवहार है जिसकी मैं अपेक्षा करता हूं, मैं नहीं देखता कि इसे कैसे विकृत किया जा सकता है, और यह काम करने के लिए एक दर्द है।

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

@rfcbot बहु-वापसी-साइटों की चिंता करता है

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

fn foo(empty: bool) -> impl Iterator<Item = u32> {
    if empty { None.into_iter() } else { &[1, 2, 3].cloned() }
}

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

fn foo(empty: bool) -> (impl Debug, impl Debug) {
    if empty { return (22, Default::default()); }
    return (Default::default(), false);
}

यहां, अनुमानित प्रकार (i32, bool) , जहां पहला return i32 भाग को सीमित करता है, और दूसरा return bool भाग को सीमित करता है।

इसका तात्पर्य यह है कि हम उन मामलों का समर्थन कभी नहीं कर सकते हैं जहां दो return बयान एकजुट नहीं होते हैं (जैसा कि मेरे पहले उदाहरण में है) - अन्यथा ऐसा करना बहुत कष्टप्रद होगा।

मुझे आश्चर्य है कि क्या हमें एक बाधा डालनी चाहिए जिसके लिए प्रत्येक return (सामान्य रूप से, एक बाधा के प्रत्येक स्रोत) को स्वतंत्र रूप से पूरी तरह से निर्दिष्ट किया जाना चाहिए? (और हम उन्हें इस तथ्य के बाद एकजुट करते हैं?)

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

@rfcbot एकाधिक-वापसी-साइटों को हल करता है

इसलिए मैंने @cramertj से # काफी हद तक बात की। हम impl Trait लिए "जल्दी वापसी" को अस्थिर बनाने के विचार पर चर्चा कर रहे थे, ताकि हम अंततः इसे बदल सकें।

उन्होंने यह मामला बनाया कि इस प्रकार के सिंटैक्स के लिए एक स्पष्ट ऑप्ट-इन करना बेहतर होगा, विशेष रूप से क्योंकि अन्य मामले हैं (उदाहरण के लिए, let x: impl Trait = if { ... } else { ... } ) जहां कोई इसे चाहेगा, और हम उम्मीद नहीं कर सकते उन सभी को निहित रूप से संभालने के लिए (निश्चित रूप से नहीं)।

मुझे यह काफी प्रेरक लगता है। इससे पहले, मैं मान रहा था कि वैसे भी हमारे पास कुछ ऑप्ट-इन सिंटैक्स होगा, लेकिन मैं सिर्फ यह सुनिश्चित करना चाहता था कि हमने समय से पहले कोई दरवाजा बंद नहीं किया। आखिरकार, जब आपको "डायनेमिक शिम" डालने की आवश्यकता होती है, तो यह समझाना मुश्किल है।

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

वह पहला foo उदाहरण, जहां तक ​​मुझे समस्या समझ में आई, या तो (1) एक बॉक्सिंग + टाइप-मिटा Iterator<Item = u32> , या (2) एक योग प्रकार std::option::Iter को हल कर सकता है std::slice::Iter , जो बदले में Iterator कार्यान्वयन प्राप्त करेगा। इसे छोटा रखने की कोशिश की जा रही है, क्योंकि चर्चा पर कुछ अपडेट थे (अर्थात्, मैंने अभी आईआरसी लॉग पढ़ा है) और इसे चुनना कठिन होता जा रहा है: मैं निश्चित रूप से डायनेमिक शिम के लिए एक डीएन-जैसे सिंटैक्स से सहमत हूं, हालांकि मैं भी समझें कि इसे dyn कहना आदर्श नहीं हो सकता है।

बेशर्म प्लग और सिर्फ रिकॉर्ड के लिए एक छोटा सा नोट: आप "गुमनाम" योग प्रकार और उत्पाद आसानी से प्राप्त कर सकते हैं:

• कोप्रोड: https://docs.rs/frunk_core/0.0.23/frunk_core/coproduct/trait.CoprodInjector.html
• एचलिस्ट: https://docs.rs/frunk_core/0.0.23/frunk_core/hlist/index.html

@Centril हाँ, फ्रंक से वह सामान बहुत अच्छा है। हालांकि, ध्यान दें कि CoprodInjector::inject काम करने के लिए, परिणामी प्रकार को अनुमानित होना चाहिए, जो आमतौर पर परिणामी प्रकार (जैसे -> Coprod!(A, B, C) ) का नाम लिए बिना असंभव है। अक्सर ऐसा होता है कि आप w/अनाम प्रकारों पर काम कर रहे हैं, इसलिए आपको -> Coprod!(impl Trait, impl Trait, impl Trait) होगी, जो अनुमान में विफल हो जाएगा क्योंकि यह नहीं जानता कि किस प्रकार में कौन सा impl Trait प्रकार होना चाहिए।

@cramertj बहुत सच है (सिडेनोट: प्रत्येक "संस्करण" पूरी तरह से अज्ञात नहीं हो सकता है, लेकिन केवल आंशिक रूप से, उदाहरण के लिए: Map<Namable, Unnameable> )।

enum impl Trait विचार पर पहले https://internals.rust-lang.org/t/pre-rfc-anonymous-enums/5695 में चर्चा की गई है

@ सेंट्रिल हाँ, यह सच है। मैं विशेष रूप से फ्यूचर्स के बारे में सोच रहा हूं, जहां मैं अक्सर चीजें लिखता हूं:

fn foo(x: Foo) -> impl Future<Item = (), Error = Never> {
    match x {
        Foo::Bar => do_request().and_then(|res| ...).left().left(),
        Foo::Baz => do_other_thing().and_then(|res| ...).left().right(),
        Foo::Boo => do_third_thing().and_then(|res| ...).right(),
    }
}

@kennytm हाँ, https://github.com/rust-lang/rfcs/pull/1154 और https://github.com/rust-lang/rfcs/issues/294 भी हैं

@क्रैमर्टज मैं यह नहीं कहूंगा कि अनाम enum impl Trait , क्योंकि हम निष्कर्ष नहीं निकाल सकते हैं X: Tr && Y: Tr ⇒ (X|Y): Tr (काउंटर उदाहरण: Default विशेषता)। तो पुस्तकालय लेखकों को मैन्युअल रूप से impl Future for (X|Y|Z|...) ।

@kennytm संभवतः हम अज्ञात एनमों के लिए कुछ विशेषता इम्प्लांट्स को उत्पन्न करना चाहते हैं, इसलिए यह मूल रूप से एक ही सुविधा की तरह लगता है।

@cramertj चूंकि एक अनाम Default लिए (i32|String) लिए एक इम्प्लांट जेनरेट किया जाता है, तो हम <(i32|String)>::default() लिख पाएंगे। ओटीओएच <enum impl Default>::default() बस संकलित नहीं होगा, इसलिए कोई फर्क नहीं पड़ता कि हम क्या स्वत: उत्पन्न करते हैं, यह अभी भी सुरक्षित रहेगा क्योंकि इसे बिल्कुल भी लागू नहीं किया जा सकता है।

फिर भी, कुछ ऐसे मामले हैं जहां ऑटो-जेनरेशन अभी भी enum impl Trait साथ समस्या पैदा कर सकता है। विचार करना

pub trait Rng {
    fn next_u32(&mut self) -> u32;
    fn gen<T: Rand>(&mut self) -> T where Self: Sized;
    fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self> where Self: Sized;
}

यह पूरी तरह से सामान्य है कि, अगर हमारे पास mut rng: (XorShiftRng|IsaacRng) तो हम rng.next_u32() या rng.gen::<u64>() गणना कर सकते हैं। हालांकि, rng.gen_iter::<u16>() निर्माण नहीं किया जा सकता क्योंकि ऑटो-जेनरेशन केवल (Generator<'a, u16, XorShiftRng>|Generator<'a, u16, IsaacRng>) उत्पादन कर सकता है, जबकि हम वास्तव में जो चाहते हैं वह Generator<'a, u16, (XorShiftRng|IsaacRng)> ।

(हो सकता है कि संकलक स्वचालित रूप से Sized चेक की तरह एक प्रतिनिधिमंडल-असुरक्षित कॉल को अस्वीकार कर सकता है।)

एफडब्ल्यूआईडब्ल्यू यह सुविधा मुझे टुपल्स की तुलना में बंद करने की भावना के करीब होने के रूप में प्रभावित करती है (जो कि निश्चित रूप से, अनाम struct काल्पनिक अनाम enum s के समकक्ष हैं)। जिस तरह से ये चीजें "गुमनाम" हैं, वह अलग है।

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

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

एक की विभिन्न शाखाओं से विभिन्न प्रकार लौटाने की क्षमता से if , एक के पीछे impl Trait , बाद के करीब लगता है - संकलक परोक्ष एक प्रकार विभिन्न शाखाओं धारण करने के लिए, औजार का अनुरोध विशेषता उत्पन्न करता है उस पर उपयुक्त व्यक्ति को भेजने के लिए, और प्रोग्रामर कभी नहीं लिखता या देखता है कि वह प्रकार क्या है, और इसका उल्लेख नहीं कर सकता है और न ही कोई वास्तविक कारण चाहता है।

(वास्तव में, यह सुविधा काल्पनिक "ऑब्जेक्ट लिटरल" से संबंधित महसूस करती है - जो अन्य लक्षणों के लिए होगी जो मौजूदा क्लोजर सिंटैक्स Fn । यानी, एक लैम्ब्डा अभिव्यक्ति के बजाय, आप दायरे में चर का उपयोग करके दिए गए विशेषता के प्रत्येक तरीके ( self निहित होने के साथ) को लागू करेगा, और संकलक अपवर्स को पकड़ने के लिए एक अज्ञात प्रकार उत्पन्न करेगा, और इसके लिए दिए गए विशेषता को लागू करेगा, यह होगा उसी तरह एक वैकल्पिक move मोड है, और इसी तरह। वैसे भी, मुझे संदेह है कि if foo() { (some future) } else { (other future) } को व्यक्त करने का एक अलग तरीका object Future { fn poll() { if foo() { (some future).poll() } else { (other future).poll() } } } (ठीक है, आपको इसकी भी आवश्यकता होगी का परिणाम लिफ्ट करने के लिए foo() बाहर में एक let तो यह केवल दूसरे के लिए

@glaebhoerl यह एक बहुत ही रोचक विचार है! यहां जावा से कुछ पूर्व कला भी है।

मेरे सिर के ऊपर से कुछ विचार (इसलिए बहुत पके हुए नहीं):

1. [बाइकशेड] उपसर्ग object पता चलता है कि यह केवल अस्तित्वगत होने के बजाय एक विशेषता वस्तु है - लेकिन ऐसा नहीं है।

एक संभावित वैकल्पिक वाक्यविन्यास:

impl Future { fn poll() { if foo() { a.poll() } else { b.poll() } } }
// ^ --
// this conflicts with inherent impls for types, so you have to delay
// things until you know whether `Future` is a type or a trait.
// This might be __very__ problematic.

// and perhaps (but probably not...):
dyn Future { fn poll() { if foo() { a.poll() } else { b.poll() } } }

1. [मैक्रोज़/चीनी] आप कुछ मामूली वाक्य रचनात्मक चीनी प्रदान कर सकते हैं ताकि आपको मिल जाए:

future!(if foo() { a.poll() } else { b.poll() })

हाँ वाक्य रचना प्रश्न एक गड़बड़ है क्योंकि यह स्पष्ट नहीं है कि क्या आप struct शाब्दिक, बंद, या impl ब्लॉक से प्रेरणा लेना चाहते हैं :) मैंने उदाहरण के लिए अपने सिर के ऊपर से सिर्फ एक को चुना है खातिर। (वैसे भी, मेरा मुख्य बिंदु यह नहीं था कि हमें जाना चाहिए और वस्तु अक्षर जोड़ना चाहिए [हालांकि हमें चाहिए] लेकिन मुझे लगता है कि अज्ञात enum s यहां एक लाल हेरिंग हैं [हालांकि हमें उन्हें भी जोड़ना चाहिए]।)

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

हम्म। इसलिए मैंने मान लिया था कि एनम प्रकारों के लिए "ताजा नाम" उत्पन्न करने के बजाय, हम इसके बजाय | प्रकारों का लाभ उठाएंगे, जो इस तरह से लागू होते हैं:

impl<A: IntoIterator, B: IntoIterator> IntoIterator for (A|B)  { /* dispatch appropriately */ }

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

-> impl IntoIterator<Item = Y>

लेकिन कहीं और हम करते हैं

-> impl IntoIterator<IntoIter = X, Item = Y>

ये दो अतिव्यापी अर्थ होंगे जो मुझे लगता है कि "एकत्रित" नहीं किया जा सकता है; ठीक है, शायद विशेषज्ञता के साथ।

वैसे भी, "गुप्त एनम" की धारणा मुझे लगता है कि चारों ओर क्लीनर लगती है।

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

@nikomatsakis : क्या यह कहना उचित है कि इस मामले में जो लौटाया जा रहा है वह dyn Trait तुलना में impl Trait , क्योंकि सिंथेटिक/अनाम वापसी मूल्य गतिशील प्रेषण के समान कुछ लागू करता है?

cc https://github.com/rust-lang/rust/issues/49288 , एक ऐसा मुद्दा जिसे मैं हाल ही में Future s और Future -रिटर्निंग विशेषता विधियों के साथ काम कर रहा हूं।

चूंकि यह आखिरी मौका है इससे पहले FCP बंद हो जाता है, मैं स्वचालित ऑटो लक्षणों के खिलाफ एक आखिरी तर्क देना चाहता हूं। मुझे एहसास है कि यह थोड़ा आखिरी मिनट है, इसलिए वर्तमान कार्यान्वयन के लिए प्रतिबद्ध होने से पहले मैं इस मुद्दे को औपचारिक रूप से संबोधित करना चाहता हूं।

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

 fn does_some_operation() -> impl Future<Item=(), Error=()> {
-    let data_stored = Arc::new("hello");
+    let data_stored = Rc::new("hello");

     return some_long_operation.and_then(|other_stuff| {
         do_other_calculation_with(data_stored)
     });
}

(सरल उदाहरण: काम करना , आंतरिक परिवर्तन विफलता का कारण बनते हैं )

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

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

जंग के विकास के दौरान, ऐसे निर्णय किए गए हैं जो उपयोगिता पर शब्दाडंबर के पक्ष में हैं। जब नवागंतुक इन्हें देखते हैं, तो उन्हें लगता है कि यह शब्दाडंबर के लिए शब्दशः है, लेकिन ऐसा नहीं है। प्रत्येक निर्णय, चाहे वह संरचनाओं को स्वचालित रूप से कॉपी लागू न करना हो, या फ़ंक्शन हस्ताक्षरों पर सभी प्रकार के स्पष्ट होना, रखरखाव के लिए है।

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

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

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

हालांकि, कोडबेस में फ़ंक्शंस और संरचनाओं का अलग-अलग उपयोग किया जाता है, और ये वही मुद्दे नहीं हैं।

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

किसी फ़ंक्शन के आंतरिक को संशोधित करते समय, यह निश्चित रूप से स्पष्ट है कि कोई प्रदर्शन और शुद्धता दोनों को प्रभावित कर सकता है। हालाँकि, रस्ट में, हमें यह जाँचने की ज़रूरत नहीं है कि हम सही प्रकार लौटा रहे हैं। फ़ंक्शन घोषणाएं एक कठिन अनुबंध है जिसे हमें बनाए रखना चाहिए, और rustc हमारी पीठ देखता है। यह स्ट्रक्चर्स और फ़ंक्शन रिटर्न में ऑटो लक्षणों के बीच एक पतली रेखा है, लेकिन किसी फ़ंक्शन के आंतरिक को बदलना अधिक नियमित है। एक बार हमारे पास पूर्ण जनरेटर-संचालित Future s हो जाने के बाद, -> impl Future लौटने वाले कार्यों को संशोधित करना और भी अधिक नियमित होगा। ये सभी परिवर्तन होंगे जो लेखकों को संशोधित भेजें/सिंक कार्यान्वयन के लिए स्क्रीन करने की आवश्यकता होगी यदि संकलक इसे पकड़ नहीं पाता है।

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

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

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

हमें गैर-भेजें/गैर-सिंक आइटम लौटने वाले कार्यों की आवश्यकता हो सकती है या तो + !Send + !Sync या एक विशेषता (उपनाम संभवतः?) यह एक अच्छा निर्णय नहीं होगा, लेकिन यह उस निर्णय से बेहतर हो सकता है जिसे हम वर्तमान में चुन रहे हैं।

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

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

पढ़ने के लिए धन्यवाद, और मुझे आशा है कि अंतिम निर्णय रस्ट को उस सर्वोत्तम दिशा में ले जाएगा जिसमें वह जा सकता है।

@daboross की समीक्षा wrt पर विस्तार। विशेषता उपनाम, कोई गैर-लीकिंग ऑटो लक्षणों के एर्गोनॉमिक्स में सुधार कर सकता है जैसे:

trait FutureNSS<T, E> = Future<Item = T, Error= E> + !Send + !Sync;

fn does_some_operation() -> impl FutureNSS<(), ()> {
     let data_stored = Rc::new("hello");
     some_long_operation.and_then(|other_stuff| {
         do_other_calculation_with(data_stored)
     });
}

यह इतना बुरा नहीं है -- आपको एक अच्छे नाम के साथ आना होगा (जो FutureNSS नहीं है)। मुख्य लाभ यह है कि यह सीमा की पुनरावृत्ति द्वारा किए गए पेपर कट को कम करता है।

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

Send आवश्यकता के बारे में क्या जब तक इसे !Send के रूप में चिह्नित नहीं किया जाता है, लेकिन सिंक के रूप में चिह्नित किए जाने तक Sync नहीं किया जाता है? क्या सिंक की तुलना में सेंड को अधिक सामान्य नहीं माना जाता है?

ऐशे ही:

fn provides_send_only1() -> impl Trait {  compatible_with_Send_and_Sync }
fn provides_send_only2() -> impl Trait {  compatible_with_Send_only }
fn fails_to_complile1() -> impl Trait {  not_compatible_with_Send }
fn provides_nothing1() -> !Send + impl Trait { compatible_with_Send}
fn provides_nothing2() -> !Send + impl Trait { not_compatible_with_Send }
fn provides_send_and_sync() -> Sync + impl Trait {  compatible_with_Send_and_Sync }
fn fails_to_compile2() -> Sync + impl Trait { compatible_with_Send_only }

क्या तर्क स्थिति और वापसी स्थिति wrt में impl Trait बीच कोई असंगति है। ऑटो लक्षण?

fn foo(x: impl ImportantTrait) {
    // Can't use Send cause we have not required it...
}

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

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

ठीक है, यह सच है के लिए आगामी ऑटो लक्षण Unpin कि गूंगा किस्मत हो रहा है (केवल आत्म संदर्भ जनरेटर के लिए नहीं-implmented), लेकिन ...? क्या यह एक सीमा है जिसके साथ हम वास्तव में रह सकते हैं? मुझे विश्वास नहीं हो रहा है कि भविष्य में ऐसा कुछ नहीं होगा जिसे अक्षम करने की आवश्यकता होगी जैसे &mut या Rc ...

मेरा मानना ​​​​है कि इस पर चर्चा की गई है, और यह निश्चित रूप से बहुत देर हो चुकी है, लेकिन मैं अभी भी तर्क स्थिति में impl Trait से असंतुष्ट हूं।

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

-> impl Trait इस प्रकार केवल 1.0 द्वारा किए गए वादे को पूरा कर रहा है, या किनारे के मामले को हटा रहा है, या मौजूदा सुविधाओं को सामान्य कर रहा है: यह कार्यों के लिए आउटपुट प्रकार जोड़ता है, उसी तंत्र को लेता है जिसे हमेशा अज्ञात प्रकारों को संभालने और इसे लागू करने के लिए उपयोग किया जाता है अधिक मामलों में। यह abstract type से शुरू करने के लिए अधिक सैद्धांतिक हो सकता है, अर्थात मॉड्यूल के लिए आउटपुट प्रकार, लेकिन यह देखते हुए कि रस्ट में एमएल मॉड्यूल सिस्टम नहीं है, ऑर्डर कोई बड़ी बात नहीं है।

fn f(t: impl Trait) इसके बजाय ऐसा लगता है कि इसे "सिर्फ इसलिए कि हम कर सकते हैं" जोड़ा गया था, बदले में पर्याप्त वापस दिए बिना भाषा को बड़ा और अजनबी बना दिया। मैंने संघर्ष किया है और इसे फिट करने के लिए कुछ मौजूदा ढांचे को खोजने में असफल रहा हूं। मैं fn f(f: impl Fn(...) -> ...) की संक्षिप्तता के आसपास के तर्क को समझता हूं, और वह औचित्य जो पहले से ही <T: Trait> और where खंडों में हो सकता है, लेकिन वे खोखले महसूस करते हैं। वे डाउनसाइड्स को नकारते नहीं हैं:

• अब आपको बाउंड्स के लिए दो सिंटैक्स सीखने होंगे- कम से कम <> / where एक सिंटैक्स साझा करें।
  
  
  
  • यह एक सीखने की चट्टान भी बनाता है और एक ही सामान्य प्रकार को कई स्थानों पर उपयोग करने के विचार को अस्पष्ट करता है।
  
  
  • नया सिंटैक्स यह बताना कठिन बनाता है कि कोई फ़ंक्शन सामान्य से अधिक है- आपको संपूर्ण तर्क सूची को स्कैन करना होगा।
  
  
• अब एक फ़ंक्शन का कार्यान्वयन विवरण क्या होना चाहिए (यह अपने प्रकार के पैरामीटर कैसे घोषित करता है) इसके इंटरफ़ेस का हिस्सा बन जाता है, क्योंकि आप इसका प्रकार नहीं लिख सकते हैं!
  
  
  
  • यह वर्तमान में चर्चा के तहत ऑटो विशेषता जटिलताओं में भी शामिल है- एक फ़ंक्शन का सार्वजनिक इंटरफ़ेस क्या है और क्या नहीं है, इसके बारे में और अधिक उलझन।
  
  
• dyn Trait साथ सादृश्य, ईमानदारी से, एक झूठा है:
  
  
  
  • dyn Trait अर्थ हमेशा एक ही होता है, और मौजूदा ऑटो विशेषता तंत्र के अलावा इसके आसपास की घोषणाओं को "संक्रमित" नहीं करता है।
  
  
  • dyn Trait डेटा संरचनाओं में प्रयोग करने योग्य है, और यह वास्तव में इसके प्राथमिक उपयोग मामलों में से एक है। डेटा संरचनाओं में impl Trait डेटा संरचना के सभी उपयोगों को देखे बिना कोई मतलब नहीं है।
  
  
  • dyn Trait अर्थ टाइप इरेज़र है, लेकिन impl Trait इसके कार्यान्वयन के बारे में कुछ भी नहीं दर्शाता है।
  
  
  • यदि हम गैर-मोनोमोर्फाइज्ड जेनरिक पेश करते हैं तो पिछला बिंदु और भी भ्रमित करने वाला होगा। वास्तव में, ऐसी स्थिति में, fn f(t: impl Trait) की संभावना a) नई सुविधा के साथ काम नहीं करेगी, और/या b) ऑटो लक्षणों के साथ समस्या की तरह और भी अधिक एज केस लॉयरिंग की आवश्यकता होगी। कल्पना कीजिए fn f<dyn T: Trait>(t: T, u: dyn impl Urait) ! :चीख:
  
  

तो यह मेरे लिए नीचे आता है कि impl Trait तर्क की स्थिति में किनारे के मामलों को जोड़ता है, अजीब बजट का अधिक उपयोग करता है, भाषा को बड़ा महसूस कराता है, आदि जबकि impl Trait वापसी की स्थिति में एकीकृत होता है, सरल करता है, और भाषा को और अधिक मजबूती से बांधे रखता है।

जब तक इसे !भेजें के रूप में चिह्नित नहीं किया जाता है, लेकिन सिंक के रूप में चिह्नित नहीं किया जाता है, तब तक भेजने की आवश्यकता के बारे में क्या है? क्या सिंक की तुलना में सेंड को अधिक सामान्य नहीं माना जाता है?

यह बहुत... मनमाना और तदर्थ लगता है। हो सकता है कि यह कम टाइपिंग है, लेकिन अधिक याद रखने वाला और अधिक अराजकता है।

बाइक शेड-y विचार यहाँ इतनी के रूप में नहीं विचलित करने के लिए ऊपर मेरी अंक से: के बजाय impl , का उपयोग type ? यह संबंधित प्रकारों के लिए उपयोग किया जाने वाला कीवर्ड है, यह संभवतः (इनमें से एक) कीवर्ड के लिए उपयोग किया गया है abstract type , यह अभी भी काफी स्वाभाविक है, और यह "फ़ंक्शंस के लिए आउटपुट प्रकार" के विचार पर अधिक संकेत देता है:

// keeping the same basic structure, just replacing the keyword:
fn f() -> type Trait

// trying to lean further into the concept:
fn f() -> type R: Trait
fn f() -> type R where R: Trait
fn f() -> (i32, type R) where R: Trait
// or perhaps:
fn f() -> type R: Trait in R
// or maybe just:
fn f() -> type: Trait

पढ़ने के लिए धन्यवाद, और मुझे आशा है कि अंतिम निर्णय रस्ट को उस सर्वोत्तम दिशा में ले जाएगा जिसमें वह जा सकता है।

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

यह मुझे लगता है कि महत्वपूर्ण प्रश्न यह है कि किस हद तक कार्य वास्तव में संरचना से भिन्न

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

यह कितना सच होगा, यह जानना वाकई मुश्किल है। ऐसा लगता है कि सामान्य नियम यह होगा कि Rc को पेश करना सावधानी के साथ किया जाना है - यह इतना अधिक नहीं है कि आप इसे Rc नहीं है बल्कि dyn Trait , क्योंकि यह कम स्पष्ट हो सकता है।)

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

किसी भी मामले में, यह निराशाजनक है क्योंकि यह एक ऐसी चीज है जिसे पहले से जानना मुश्किल है, चाहे हम इसे कितनी भी स्थिर अवधि दें।

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

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

@rpjohnst

मुझे विश्वास है कि इस पर चर्चा की गई है

वास्तव में, यह कई वर्षों पहले पहले impl Trait RFC lo के बाद से :) है। (वाह, 2014। मैं बूढ़ा महसूस करता हूं।)

मैंने संघर्ष किया है और इसे फिट करने के लिए कुछ मौजूदा ढांचे को खोजने में असफल रहा हूं।

मैं इसके ठीक विपरीत महसूस करता हूं। मेरे लिए, तर्क स्थिति में impl Trait बिना, impl Trait वापसी की स्थिति में और भी अधिक खड़ा है। मैं जो एकीकृत धागा देखता हूं वह है:

• impl Trait - जहां यह दिखाई देता है, यह इंगित करता है कि "कुछ मोनोमोर्फाइज्ड प्रकार होगा जो Trait "। (यह सवाल कि उस प्रकार को कौन निर्दिष्ट करता है - कॉलर या कैली - इस पर निर्भर करता है कि impl Trait कहां दिखाई देता है।)
• dyn Trait - जहां यह दिखाई देता है, यह इंगित करता है कि कुछ प्रकार होगा जो Trait , लेकिन यह कि प्रकार का चुनाव गतिशील रूप से किया जाता है।

उन स्थानों के सेट का विस्तार करने की भी योजना है जहां impl Trait प्रकट हो सकता है, उस अंतर्ज्ञान पर निर्माण। उदाहरण के लिए, https://github.com/rust-lang/rfcs/pull/2071 परमिट

let x: impl Trait = ...;

वही सिद्धांत लागू होता है: प्रकार की पसंद को सांख्यिकीय रूप से जाना जाता है। इसी तरह, वही RFC abstract type (जिसके लिए impl Trait को एक प्रकार की वाक्यात्मक चीनी के रूप में समझा जा सकता है) का परिचय देता है, जो कि विशेषता के रूप में और यहां तक ​​कि मॉड्यूल में सदस्यों के रूप में प्रकट हो सकता है।

बाइक शेड-y विचार यहाँ इतनी के रूप में नहीं विचलित करने के लिए ऊपर मेरी अंक से: के बजाय impl , का उपयोग type ?

निजी तौर पर, मैं यहां एक बाइकशेड को बहाल करने के लिए इच्छुक नहीं हूं। हमने https://github.com/rust-lang/rfcs/pull/2071 और अन्य जगहों पर सिंटैक्स पर चर्चा करने में काफी समय बिताया। एक "सही कीवर्ड" प्रतीत नहीं होता है, लेकिन impl को "कुछ प्रकार जो लागू करता है" के रूप में पढ़ना बहुत अच्छी तरह से काम करता है।

मुझे ऑटो विशेषता रिसाव के बारे में कुछ और जोड़ने दें:

सबसे पहले, अंततः मुझे लगता है कि ऑटो विशेषता रिसाव वास्तव में यहां करने के लिए सही काम है, ठीक है क्योंकि यह बाकी भाषा के अनुरूप है। ऑटो लक्षण थे - जैसा कि मैंने पहले कहा था - हमेशा एक जुआ, लेकिन ऐसा लगता है कि वे मूल रूप से भुगतान कर चुके हैं। मैं बस impl Trait को इतना अलग नहीं देखता।

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

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

तो - कम से कम इस क्षण के रूप में - मैं अभी भी वर्तमान पथ को जारी रखने के इच्छुक हूं।

निजी तौर पर, मैं यहां एक बाइकशेड को बहाल करने के लिए इच्छुक नहीं हूं।

मैंने इसमें बहुत अधिक निवेश नहीं किया है; यह मेरी धारणा के आधार पर एक विचार था कि तर्क की स्थिति में impl Trait शब्दार्थ के बजाय वाक्यात्मक रूप से "छेद भरने" से प्रेरित प्रतीत होता है, जो आपकी प्रतिक्रिया को देखते हुए सही लगता है। :)

मेरे लिए, तर्क स्थिति में impl Trait बिना, impl Trait वापसी की स्थिति में और भी अधिक खड़ा है।

संबद्ध प्रकारों की सादृश्यता को देखते हुए, यह "बिना type T के तर्क की स्थिति में, संबंधित प्रकार और भी अधिक बाहर खड़े होते हैं।" मुझे संदेह है कि विशेष आपत्ति सामने नहीं आई है क्योंकि हमने जो वाक्य-विन्यास चुना है, वह इसे निरर्थक बनाता है- मौजूदा वाक्यविन्यास इतना अच्छा है कि किसी को भी वाक्यात्मक चीनी की आवश्यकता महसूस नहीं होती है जैसे trait Trait<type SomeAssociatedType> ।

हमारे पास पहले से ही "कुछ मोनोमोर्फाइज्ड प्रकार के लिए सिंटैक्स है जो Trait ।" लक्षणों के मामले में, हमारे पास "कॉलर" और "कैली" -निर्दिष्ट प्रकार दोनों हैं। फ़ंक्शंस के मामले में, हमारे पास केवल कॉलर-निर्दिष्ट संस्करण है, इसलिए हमें कैली-निर्दिष्ट संस्करण के लिए नए सिंटैक्स की आवश्यकता है।

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

जैसा कि मैंने अपनी पिछली टिप्पणी में उल्लेख किया था, मैं भी abstract type का प्रशंसक हूं। यह, फिर से, मॉड्यूल के लिए "आउटपुट प्रकार" अवधारणा का विस्तार है। और -> impl Trait , let x: impl Trait , और abstract type संबंधित प्रकारों को लागू करना भी बहुत अच्छा है।

यह विशेष रूप से फ़ंक्शन तर्कों के लिए इस नए वाक्यविन्यास को जोड़ने की अवधारणा है जिसे मैं नापसंद करता हूं। यह वैसा ही काम नहीं करता जैसा कि इसके साथ खींची जा रही किसी भी अन्य विशेषता के साथ होता है। यह वाक्य रचना हम पहले से ही है के रूप में एक ही बात क्या करता है, बस अधिक बढ़त मामलों और कम प्रयोज्यता के साथ। :/

@nikomatsakis

यह कितना सच होगा, यह जानना वाकई मुश्किल है।

मुझे ऐसा लगता है कि हमें रूढ़िवादी होने के पक्ष में गलती करनी चाहिए? क्या हम अधिक समय के साथ डिजाइन में अधिक विश्वास हासिल कर सकते हैं (ऑटो विशेषता रिसाव को एक अलग फीचर गेट के तहत और केवल रात में, जबकि हम बाकी impl Trait स्थिर करते हैं)? यदि हम अभी लीक नहीं करते हैं तो हम बाद में हमेशा ऑटो विशेषता रिसाव के लिए समर्थन जोड़ सकते हैं।

लेकिन साथ ही, मैं यहां देरी करने को लेकर काफी नर्वस हूं। [..] मैं बहुत चिंतित हूं कि अगर हम अभी देरी करते हैं तो हमें वर्ष के लिए अपने रोडमैप पर पहुंचने में मुश्किल होगी।

समझ में आता है! हालाँकि, और जैसा कि मुझे यकीन है कि आपने विचार किया है, यहाँ के निर्णय आने वाले कई वर्षों तक हमारे साथ रहेंगे।

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

यह सुनना अच्छा है! और मुझे लगता है कि यह ज्यादातर मेरी चिंताओं को शांत करता है।

सच है, हालांकि मैं निश्चित रूप से Send जैसे विशिष्ट ऑटो लक्षणों को "सिंगलिंग आउट" करने के विचार से घबराता हूं।

मैं इस भावना से बहुत सहमत हूँ .

किसी भी मामले में, आप वास्तव में क्या चाहते हैं, और जिसे हम स्थगित करने का प्रयास कर रहे हैं =), एक प्रकार का "सशर्त" बाध्य है (भेजें यदि T भेजें है)। यह ठीक वही है जो ऑटो लक्षण आपको देते हैं।

मुझे लगता है कि अगर कोड ने स्पष्ट रूप से यह कहा है तो T: Send => Foo<T>: Send बेहतर ढंग से समझा जाएगा।

fn foo<T: Extra, trait Extra = Send>(x: T) -> impl Bar + Extra {..}

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

@rpjohnst

dyn Trait साथ सादृश्य, ईमानदारी से, एक झूठा है:

तर्क की स्थिति में impl Trait में यह गलत है, लेकिन -> impl Trait साथ ऐसा नहीं है क्योंकि दोनों अस्तित्वगत प्रकार हैं।

• अब एक फ़ंक्शन का कार्यान्वयन विवरण क्या होना चाहिए (यह अपने प्रकार के मापदंडों को कैसे घोषित करता है) इसके इंटरफ़ेस का हिस्सा बन जाता है, क्योंकि आप इसका प्रकार नहीं लिख सकते हैं!

मैं यह नोट करना चाहता हूं कि टर्बोफिश के कारण टाइप पैरामीटर का क्रम कभी भी कार्यान्वयन विवरण नहीं रहा है, और इस संबंध में, मुझे लगता है कि impl Trait मदद कर सकता है क्योंकि यह आपको टर्बोफिश में निर्दिष्ट कुछ प्रकार के तर्कों को छोड़ने की अनुमति देता है .

[..] वहां मौजूद सिंटैक्स इतना अच्छा है कि किसी को भी सिंटैक्टिक शुगर जैसे लक्षण विशेषता की आवश्यकता महसूस नहीं होती है.

नेवर से नेवर? https://github.com/rust-lang/rfcs/issues/2274

@nikomatsakis की तरह, मैं वास्तव में इन अंतिम-मिनट की टिप्पणियों में की गई देखभाल की सराहना करता हूं; मुझे पता है कि यह एक मालगाड़ी के सामने खुद को फेंकने की कोशिश करने जैसा महसूस कर सकता है, विशेष रूप से एक ऐसी सुविधा के लिए जो लंबे समय से वांछित है!

@daboross , मैं ऑप्ट-आउट विचार में थोड़ा और ड्रिल करना चाहता था। पहली बार में यह आशाजनक लगता है, क्योंकि यह हमें हस्ताक्षर को पूरी तरह से बताने की अनुमति देगा, लेकिन चूक के साथ जो सामान्य मामले को संक्षिप्त बना देता है।

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

• यदि ऑटो लक्षणों को impl Trait लिए ऑप्ट-आउट के रूप में माना जाता था, तो उन्हें dyn Trait लिए भी होना चाहिए।
• यह निश्चित रूप से तब भी लागू होता है जब इन निर्माणों का उपयोग तर्क स्थिति में किया जाता है।
• लेकिन फिर, जेनरिक के लिए अलग तरह से व्यवहार करना अजीब होगा। दूसरे शब्दों में, fn foo<T>(t: T) , आप डिफ़ॉल्ट रूप से T: Send अपेक्षा कर सकते हैं।
• बेशक हमारे पास इसके लिए एक तंत्र है, जो वर्तमान में केवल Sized ; यह एक विशेषता है जिसे हर जगह डिफ़ॉल्ट रूप से माना जाता है, और जिसके लिए आप ?Sized लिखकर ऑप्ट आउट करते हैं

?Sized तंत्र रस्ट के सबसे अस्पष्ट और सिखाने के लिए कठिन पहलुओं में से एक है, और हम सामान्य रूप से इसे अन्य अवधारणाओं तक विस्तारित करने के लिए बेहद घृणास्पद रहे हैं। एक अवधारणा के लिए इसे Send रूप में केंद्रीय के रूप में उपयोग करना जोखिम भरा लगता है - यह उल्लेख नहीं है कि यह एक बड़ा ब्रेकिंग परिवर्तन होगा।

और क्या है, हालांकि: हम वास्तव में जेनरिक के लिए एक ऑटो विशेषता धारणा में सेंकना नहीं चाहते हैं, क्योंकि आज जेनरिक की सुंदरता का हिस्सा यह है कि आप प्रभावी रूप से सामान्य हो सकते हैं कि एक प्रकार एक ऑटो विशेषता लागू करता है या नहीं, और वह जानकारी बस है "के माध्यम से प्रवाह"। उदाहरण के लिए, fn f<T>(t: T) -> Option<T> । हम T में पास कर सकते हैं चाहे वह Send , और आउटपुट Send iff T था। यह रस्ट में जेनरिक कहानी का एक अत्यंत महत्वपूर्ण हिस्सा है।

dyn Trait साथ भी समस्याएं हैं। विशेष रूप से, अलग संकलन के कारण, हमें इस "ऑप्ट आउट" प्रकृति को केवल "प्रसिद्ध" ऑटो लक्षणों जैसे Send और Sync तक सीमित रखना होगा; इसका मतलब शायद बाहरी उपयोग के लिए auto trait को स्थिर नहीं करना होगा।

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

@rpjohnst

आरएफसी और @nikomatsakis की सारांश टिप्पणी पर व्यापक चर्चा के बाद मेरे पास तर्क स्थिति के मुद्दे पर जोड़ने के लिए बहुत कुछ नहीं है।

अब एक फ़ंक्शन का कार्यान्वयन विवरण क्या होना चाहिए (यह अपने प्रकार के मापदंडों को कैसे घोषित करता है) इसके इंटरफ़ेस का हिस्सा बन जाता है, क्योंकि आप इसका प्रकार नहीं लिख सकते हैं!

मुझे समझ नहीं आ रहा है कि आपका इससे क्या मतलब है। क्या आप विस्तार कर सकते हैं?

मैं यह भी नोट करना चाहता हूं कि वाक्यांश जैसे:

fn f(t: impl Trait) इसके बजाय ऐसा लगता है कि इसे "सिर्फ इसलिए कि हम कर सकते हैं" जोड़ा गया था

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

ट्रेडऑफ़ मौजूद हैं, वास्तव में डाउनसाइड्स हैं, लेकिन यह हमें बहस के "दूसरे पक्ष" के व्यंग्यात्मक निष्कर्ष तक पहुंचने में मदद नहीं करता है।

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

auto Trait रिसाव

auto Trait रिसाव के विचार ने मुझे लंबे समय तक परेशान किया-- कुछ मायनों में, यह रस्ट के कई डिज़ाइन लक्ष्यों के विपरीत लग सकता है। अपने पूर्वजों की तुलना में, जैसे कि C++ या ML परिवार, रस्ट इस मायने में असामान्य है कि इसे फ़ंक्शन घोषणाओं में स्पष्ट रूप से बताए जाने के लिए सामान्य सीमा की आवश्यकता होती है। मेरी राय में, यह रस्ट के सामान्य कार्यों को पढ़ने और समझने में आसान बनाता है, और यह अपेक्षाकृत स्पष्ट करता है जब एक पश्च-असंगत परिवर्तन किया जा रहा हो। हमने इस पैटर्न को const fn अपने दृष्टिकोण में जारी रखा है, फ़ंक्शन निकायों से const नेस का उल्लेख करने के बजाय कार्यों को स्पष्ट रूप से const रूप में निर्दिष्ट करने की आवश्यकता है। स्पष्ट विशेषता सीमाओं की तरह, इससे यह बताना आसान हो जाता है कि कौन से फ़ंक्शन किस तरह से उपयोग करने योग्य हैं, और पुस्तकालय लेखकों को यह विश्वास दिलाता है कि छोटे कार्यान्वयन परिवर्तन उपयोगकर्ताओं को नहीं तोड़ेंगे।

उस ने कहा, मैंने अपनी परियोजनाओं में बड़े पैमाने पर रिटर्न-पोजिशन impl Trait किया है, जिसमें फ्यूशिया ऑपरेटिंग सिस्टम पर मेरा काम भी शामिल है, और मेरा मानना ​​​​है कि ऑटो विशेषता रिसाव यहां सही डिफ़ॉल्ट है। व्यावहारिक रूप से, रिसाव को हटाने का परिणाम यह होगा कि मुझे वापस जाना होगा और + Send को मूल रूप से प्रत्येक impl Trait मेरे द्वारा लिखे गए फ़ंक्शन का उपयोग करके जोड़ना होगा। नकारात्मक सीमाएं ( + !Send ) मेरे लिए एक दिलचस्प विचार है, लेकिन फिर मैं लगभग सभी समान कार्यों पर + !Unpin लिखूंगा। स्पष्टता तब सहायक होती है जब यह उपयोगकर्ताओं के निर्णयों को सूचित करती है या कोड को अधिक समझने योग्य बनाती है। इस मामले में, मुझे लगता है कि यह न तो होगा।

Send और Sync ऐसे "संदर्भ" हैं जिनमें उपयोगकर्ता प्रोग्राम करते हैं: यह अत्यंत दुर्लभ है कि मैं एक एप्लिकेशन या लाइब्रेरी लिखता हूं जो Send और !Send प्रकार का उपयोग करता है (विशेष रूप से केंद्रीय निष्पादक पर चलाने के लिए एसिंक कोड लिखते समय, जो या तो बहुप्रचारित है या नहीं)। थ्रेड-सुरक्षित होने या न होने का विकल्प पहले विकल्पों में से एक है जिसे एक आवेदन लिखते समय किया जाना है, और वहां से, थ्रेड-सुरक्षित होने का मतलब है कि मेरे सभी प्रकार Send । पुस्तकालयों के लिए, यह लगभग हमेशा ऐसा होता है कि मैं Send प्रकार पसंद करता हूं, क्योंकि उनका उपयोग नहीं करने का आमतौर पर मतलब है कि थ्रेडेड संदर्भ में उपयोग किए जाने पर मेरी लाइब्रेरी अनुपयोगी है (या एक समर्पित थ्रेड बनाने की आवश्यकता है)। एक निर्विरोध parking_lot::Mutex का प्रदर्शन लगभग RefCell समान होगा जब आधुनिक CPU पर उपयोग किया जाता है, इसलिए मुझे !Send उपयोग के लिए उपयोगकर्ताओं को विशेष पुस्तकालय कार्यक्षमता की ओर धकेलने के लिए कोई प्रेरणा नहीं दिखती है- मामले इन कारणों से, मुझे नहीं लगता कि फ़ंक्शन-हस्ताक्षर स्तर पर Send और !Send प्रकारों के बीच अंतर करने में सक्षम होना महत्वपूर्ण है, और मुझे नहीं लगता कि यह सामान्य होगा पुस्तकालय लेखकों ने गलती से !Send प्रकारों को impl Trait प्रकारों में पेश कर दिया जो पहले Send । यह सच है कि यह विकल्प पठनीयता और स्पष्टता लागत के साथ आता है, लेकिन मेरा मानना ​​​​है कि एर्गोनोमिक और प्रयोज्य लाभों के लिए ट्रेड-ऑफ इसके लायक है।

तर्क-स्थिति impl Trait

मेरे पास यहाँ कहने के लिए बहुत कुछ नहीं है, सिवाय इसके कि हर बार जब मैं तर्क-स्थिति impl Trait लिए पहुँचता हूँ, तो मैंने पाया है कि इसने मेरे फ़ंक्शन हस्ताक्षरों की पठनीयता और समग्र सुखदता को बहुत बढ़ा दिया है। यह सच है कि यह एक नई क्षमता नहीं जोड़ता है जो आज के जंग में संभव नहीं है, लेकिन यह जटिल फ़ंक्शन हस्ताक्षरों के लिए एक महान गुणवत्ता-जीवन सुधार है, यह अच्छी तरह से अवधारणात्मक रूप से वापसी-स्थिति impl Trait , और यह OOP प्रोग्रामर्स के ट्रांजिशन को हैप्पी रुस्तेसियन में आसान बनाता है। वर्तमान में, केवल एक बाउंड प्रदान करने के लिए एक नामित जेनेरिक प्रकार को पेश करने के लिए बहुत अधिक अतिरेक है (उदाहरण के लिए F में fn foo<F>(x: F) where F: FnOnce() बनाम fn foo(x: impl FnOnce()) )। यह परिवर्तन उस समस्या को हल करता है और फ़ंक्शन हस्ताक्षर में परिणाम देता है जो पढ़ने और लिखने में आसान होते हैं, और आईएमओ -> impl Trait साथ एक प्राकृतिक फिट की तरह महसूस करता है।

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

@सेंट्रिल

तर्क की स्थिति में विशेषता को निहित करने के संबंध में यह गलत है, लेकिन ऐसा नहीं है -> निहित विशेषता क्योंकि दोनों अस्तित्वगत प्रकार हैं।

हाँ, मेरा यही मतलब था।

@aturon

जैसे वाक्यांश ... अच्छे विश्वास की चर्चा को कमजोर करते हैं

आप सही कह रहे हैं, इसके लिए खेद है। मुझे विश्वास है कि मैंने अपनी बात कहीं और बेहतर की है।

अब एक फ़ंक्शन का कार्यान्वयन विवरण क्या होना चाहिए (यह अपने प्रकार के मापदंडों को कैसे घोषित करता है) इसके इंटरफ़ेस का हिस्सा बन जाता है, क्योंकि आप इसका प्रकार नहीं लिख सकते हैं!

मुझे समझ नहीं आ रहा है कि आपका इससे क्या मतलब है। क्या आप विस्तार कर सकते हैं?

तर्क स्थिति में impl Trait समर्थन के साथ, आप इस फ़ंक्शन को दो तरीकों से लिख सकते हैं:

fn f(t: impl Trait)
fn f<T: Trait>(t: T)

फॉर्म का चुनाव यह निर्धारित करता है कि क्या एपीआई उपभोक्ता किसी विशेष इंस्टेंटेशन का नाम भी लिख सकता है (उदाहरण के लिए उसका पता लेना)। impl Trait वैरिएंट आपको ऐसा करने नहीं देता है, और <T> सिंटैक्स का उपयोग करने के लिए हस्ताक्षर को फिर से लिखे बिना इसे हमेशा काम नहीं किया जा सकता है। इसके अलावा, <T> सिंटैक्स में जाना एक महत्वपूर्ण बदलाव है!

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

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

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

@cramertj जहां तक ​​फंक्शन सिग्नेचर रिडंडेंसी की बात है ... क्या हम इससे किसी और तरीके से छुटकारा पा सकते हैं? इन-बैंड लाइफटाइम बिना बैकरेफरेंस के दूर जाने में सक्षम थे; शायद हम किसी भी तरह "इन-बैंड प्रकार पैरामीटर" के नैतिक समकक्ष कर सकते हैं। या दूसरे शब्दों में, "परिवर्तन उतना ही सामान्य है और इसे सार्वभौमिक रूप से लागू करने का इरादा है।"

@rpjohnst

इसके अलावा, <T> सिंटैक्स में जाना एक महत्वपूर्ण बदलाव है!

जरूरी नहीं, https://github.com/rust-lang/rfcs/pull/2176 के साथ आप अंत में एक अतिरिक्त प्रकार का पैरामीटर जोड़ सकते हैं T: Trait और टर्बोफिश अभी भी काम करेगा (जब तक कि आप टूटने की बात नहीं कर रहे हैं टर्बोफिश-ब्रेकेज के अलावा कुछ अन्य साधन)।

अंतर्निहित विशेषता संस्करण आपको ऐसा करने नहीं देता है, और <T> सिंटैक्स का उपयोग करने के लिए हस्ताक्षर को फिर से लिखे बिना इसे हमेशा काम नहीं किया जा सकता है। इसके अलावा, <T> सिंटैक्स में जाना एक महत्वपूर्ण बदलाव है!

साथ ही, मुझे लगता है कि आपका मतलब है कि <T> सिंटैक्स से आगे बढ़ना एक ब्रेकिंग परिवर्तन है (क्योंकि कॉलर अब स्पष्ट रूप से टर्बोफिश का उपयोग करके T का मान निर्दिष्ट नहीं कर सकते हैं)।

अद्यतन करें: ध्यान दें कि यदि कोई फ़ंक्शन इम्प्लांट विशेषता का उपयोग करता है, तो हम वर्तमान में टर्बोफ़िश का उपयोग करने की बिल्कुल भी अनुमति नहीं देते हैं - भले ही उसके कुछ सामान्य सामान्य पैरामीटर हों।

स्पष्ट वाक्य रचना करने के लिए आगे बढ़ते @nikomatsakis एक तोड़ने परिवर्तन के रूप में अच्छी तरह से, अगर पुराने हस्ताक्षर स्पष्ट प्रकार पैरामीटर और निहित लोगों का मिश्रण था हो सकता है - जो कोई प्रदान की n प्रकार पैरामीटर अब प्रदान करना होगा n + 1 इसके बजाय @Centril के RFC ने हल करने का लक्ष्य रखा था।

अद्यतन करें: ध्यान दें कि यदि कोई फ़ंक्शन इम्प्लांट विशेषता का उपयोग करता है, तो हम वर्तमान में टर्बोफ़िश का उपयोग करने की बिल्कुल भी अनुमति नहीं देते हैं - भले ही उसके कुछ सामान्य सामान्य पैरामीटर हों।

यह तकनीकी रूप से ब्रेकिंग मामलों की संख्या को कम करता है, लेकिन दूसरी ओर यह उन मामलों की संख्या को बढ़ाता है जहां आप किसी विशिष्ट इंस्टेंटेशन को नाम नहीं दे सकते। :(

@nikomatsakis

इस चिंता को ईमानदारी से संबोधित करने के लिए धन्यवाद।

मुझे अभी भी यह कहने में संकोच हो रहा है कि ऑटो विशेषता लीकिंग _the right_ समाधान है, लेकिन मैं मानता हूं कि हम वास्तव में यह नहीं जान सकते कि तथ्य के बाद तक सबसे अच्छा क्या है।

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

मैं Sync और Send और _only_ को अलग नहीं करना चाहता था, क्योंकि यह थोड़ा मनमाना है और केवल _one_ उपयोग के मामले के लिए सबसे अच्छा है। हालाँकि, सभी ऑटो लक्षणों को मानने का विकल्प भी अच्छा नहीं होगा। + !Unpin + !... हर प्रकार पर एक व्यवहार्य समाधान की तरह नहीं लगता है।

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

@lफेयरी

यदि पुराने हस्ताक्षर में स्पष्ट प्रकार के मापदंडों और निहित लोगों का मिश्रण था, तो स्पष्ट सिंटैक्स में जाना एक ब्रेकिंग परिवर्तन हो सकता है - n प्रकार के पैरामीटर प्रदान करने वाले को अब इसके बजाय n + 1 प्रदान करने की आवश्यकता होगी।

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

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

@lफेयरी

यह उन मामलों में से एक था जिसे @Centril के RFC ने हल करने का लक्ष्य रखा था।

_[सामान्य ज्ञान]_ संयोग से, यह वास्तव में @nikomatsakis था जिसने मेरे ध्यान में लाया कि आंशिक टर्बोफिश <T: Trait> और impl Trait बीच के ब्रेक को कम कर सकता है;) यह RFC का लक्ष्य नहीं था शुरुआत से ही, लेकिन यह एक अच्छा आश्चर्य था। मैं

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

अंतिम टिप्पणी अवधि अब पूरी हो गई है।

अगर इसे 1.26 में भेजा जा रहा है तो https://github.com/rust-lang/rust/issues/49373 मुझे बहुत महत्वपूर्ण लगता है, Future और Iterator दो प्रमुख उपयोग हैं -केस और वे दोनों संबंधित प्रकारों को जानने पर बहुत निर्भर हैं।

समस्या ट्रैकर में त्वरित खोज की, और #47715 एक ICE है जिसे अभी भी ठीक करने की आवश्यकता है। क्या हम इसे स्थिर होने से पहले प्राप्त कर सकते हैं?

कुछ ऐसा जो मैंने आज इम्प्लांट ट्रैट के साथ किया:
https://play.rust-lang.org/?gist=69bd9ca4d41105f655db5f01ff444496&version=stable

ऐसा लगता है कि impl Trait , unimplemented!() साथ असंगत है - क्या यह एक ज्ञात समस्या है?

हाँ, देखें #36375 और #44923

मैंने अभी-अभी महसूस किया है कि RFC 1951 की धारणा 2 मेरे impl Trait कुछ नियोजित उपयोगों के खिलाफ async ब्लॉकों के साथ चलती है। विशेष रूप से यदि आप अधिक एर्गोनोमिक एपीआई रखने के लिए सामान्य AsRef या Into पैरामीटर लेते हैं, तो async ब्लॉक वापस करने से पहले इसे कुछ स्वामित्व वाले प्रकार में बदल दें, फिर भी आपको रिटर्न मिलता है impl Trait प्रकार उस पैरामीटर में किसी भी जीवनकाल द्वारा बाध्य किया जा रहा है, उदाहरण के लिए

impl HttpClient {
    fn get(&mut self, url: impl Into<Url>) -> impl Future<Output = Response> + '_ {
        let url = url.into();
        async {
            // perform the get
        }
    }
}

fn foo(client: &mut HttpClient) -> impl Future<Output = Response> + '_ {
    let url = Url::parse("http://foo.example.com").unwrap();
    client.get(&url)
}

इसके साथ आपको एक error[E0597]: `url` does not live long enough मिलेगा क्योंकि get में लौटाए गए impl Future में अस्थायी संदर्भ का जीवनकाल शामिल है। इस उदाहरण में थोड़ा सा योगदान दिया गया है कि आप get में मूल्य से यूआरएल पास कर सकते हैं, लेकिन वास्तविक कोड में लगभग निश्चित रूप से इसी तरह के मामले सामने आएंगे।

जहाँ तक मैं बता सकता हूँ कि इसके लिए अपेक्षित सुधार सार प्रकार है, विशेष रूप से

impl HttpClient {
    abstract type Get<'a>: impl Future<Output = Response> + 'a;
    fn get(&mut self, url: impl Into<Url>) -> Self::Get<'_> {
        let url = url.into();
        async {
            // perform the get
        }
    }
}

अप्रत्यक्ष की परत जोड़कर आपको स्पष्ट रूप से गुजरना होगा कि सार प्रकार के लिए सामान्य प्रकार और आजीवन पैरामीटर की आवश्यकता होती है।

मैं सोच रहा हूं कि क्या इसे लिखने का संभावित रूप से एक और संक्षिप्त तरीका है, या क्या यह लगभग हर फ़ंक्शन के लिए उपयोग किए जा रहे अमूर्त प्रकारों के साथ समाप्त हो जाएगा और कभी भी impl Trait रिटर्न प्रकार नहीं होगा?

@ Nemo157 हाँ, देखें https://github.com/rust-lang/rust/issues/42940

इसलिए, अगर मैं उस मुद्दे पर @cramertj की टिप्पणी को समझता हूं तो आपको HttpClient::get की परिभाषा पर एक त्रुटि मिलेगी जैसे `get` returns an `impl Future` type which is bounded to live for `'_`, but this type could potentially contain data with a shorter lifetime inside the type of `url` । (चूंकि आरएफसी स्पष्ट रूप से निर्दिष्ट करता है कि impl Trait _all_ सामान्य प्रकार के पैरामीटर को कैप्चर करता है, और यह एक बग है जिसे आपको एक प्रकार को कैप्चर करने की अनुमति है जिसमें आपके स्पष्ट रूप से घोषित जीवनकाल से कम जीवनकाल हो सकता है)।

इससे एकमात्र फिक्स अभी भी नाममात्र सार प्रकार घोषित करने के लिए प्रतीत होता है ताकि स्पष्ट रूप से घोषित किया जा सके कि किस प्रकार के पैरामीटर कैप्चर किए गए हैं।

दरअसल, ऐसा लगता है कि यह एक ब्रेकिंग बदलाव होगा। तो अगर उस मामले में कोई त्रुटि जोड़ी जा रही है, तो यह जल्द ही बेहतर होगा।

संपादित करें: और टिप्पणी को दोबारा पढ़ना, मुझे नहीं लगता कि यह वही कह रहा है, इसलिए मैं अभी भी उलझन में हूं कि अमूर्त प्रकारों का उपयोग किए बिना इसके आसपास कोई संभावित तरीका है या नहीं।

@ Nemo157 हां, #42940 को ठीक करने से आपकी जीवन भर की समस्या ठीक हो जाएगी क्योंकि आप यह निर्दिष्ट कर सकते हैं कि रिटर्न प्रकार को स्वयं के उधार के रूप में लंबे समय तक रहना चाहिए, चाहे Url का जीवनकाल कुछ भी हो। यह निश्चित रूप से एक बदलाव है जिसे हम करना चाहते हैं, लेकिन मेरा मानना ​​​​है कि ऐसा करने के लिए यह पिछड़ा-संगत है-- यह रिटर्न प्रकार को कम जीवनकाल की अनुमति नहीं दे रहा है, यह उन तरीकों को अधिक प्रतिबंधित कर रहा है जिनमें रिटर्न प्रकार का उपयोग किया जा सकता है।

उदाहरण के लिए, "पैरामीटर Iter साथ निम्न त्रुटियाँ पर्याप्त समय तक नहीं रह सकती हैं":

fn foo<'a, Iter>(_: &'a mut u32, iter: Iter) -> impl Iterator<Item = u32> + 'a
    where Iter: Iterator<Item = u32>
{
    iter
}

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

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

क्या कोई कारण है कि सिंटैक्स abstract type Foo = ...; को type Foo = impl ...; से अधिक चुना गया था? मैंने वाक्य रचना की निरंतरता के लिए बाद वाले को बहुत पसंद किया, और मुझे कुछ समय पहले इस पर कुछ चर्चा याद है, लेकिन यह प्रतीत नहीं होता है।

मैं type Foo = impl ...; या type Foo: ...; आंशिक हूं, abstract एक अनावश्यक ऑडबॉल लगता है।

अगर मुझे ठीक से याद है, तो मुख्य चिंताओं में से एक यह थी कि लोगों ने type X = Y को एक पाठ्य प्रतिस्थापन के रूप में व्याख्या करना सीख लिया है ("जहां लागू हो X को Y बदलें")। यह type X = impl Y लिए काम नहीं करता है।

मैं स्वयं type X = impl Y हूं क्योंकि मेरा अंतर्ज्ञान यह है कि type let तरह काम करता है, लेकिन...

@alexreg इस विषय पर RFC 2071 पर बहुत सारी चर्चाएँ हैं। TL; DR: type Foo = impl Trait; impl Trait को कुछ "अधिक स्पष्ट" रूप में desugar करने की क्षमता को तोड़ता है, और यह लोगों के अंतर्ज्ञान को तोड़ता है जो कि थोड़े से स्मार्ट वाक्यात्मक प्रतिस्थापन के रूप में काम कर रहे उपनामों के बारे में है।

मैं टाइप करने के लिए आंशिक हूँ Foo = impl ...; या टाइप करें फू: ...;, एब्सट्रैक्ट एक अनावश्यक ऑडबॉल लगता है

आपको मेरे exists type Foo: Trait; शिविर में शामिल होना चाहिए: पलक:

@क्रैमर्टज हम्म। मैंने उनमें से कुछ पर अभी-अभी खुद को तरोताजा किया है, और अगर मैं ईमानदार हूं तो मैं यह नहीं कह सकता कि मैं @withboats के तर्क को समझता https://github.com/rust-lang/rfcs/pull/2071#issuecomment -319012123 जैसी चीजों को करने के लिए यह सिंटैक्स सबसे अच्छा है - क्या यह वर्तमान सिंटैक्स में भी किया जा सकता है?

exists type Foo: Trait; थोड़ा सुधार है, हालांकि मैं अभी भी exists कीवर्ड को छोड़ दूंगा। type Foo: Trait; मुझे शिकायत करने के लिए पर्याप्त परेशान नहीं करेगा। 😉 abstract सिर्फ ज़रूरत से ज़्यादा/ विषम गेंद है , जैसा कि

@alexreg

क्या यह वर्तमान वाक्यविन्यास में भी किया जा सकता है?

हाँ, लेकिन यह बहुत अधिक अजीब है। = impl Trait सिंटैक्स ( abstract कीवर्ड मॉड्यूल) को प्राथमिकता देने का यह मेरा प्राथमिक कारण था।

type Foo = (impl Bar, impl Baz);
type IterDisplay = impl Iterator<Item=impl Display>;

// can be written like this:

exists type Foo1: Bar;
exists type Foo2: Baz;
exists type Foo: (Foo1, Foo2);

exists type IterDisplayItem: Display;
exists type IterDisplay: Iterator<Item=IterDisplayItem>;

संपादित करें: exists type Foo: (Foo1, Foo2); ऊपर type Foo = (Foo1, Foo2); होना चाहिए था। गलतफहमी के लिए खेद है।

@cramertj वाक्यविन्यास अच्छा लगता है। क्या exists एक उचित कीवर्ड होना चाहिए?

@cramertj ठीक है, मैं सोच रहा था कि आपको ऐसा कुछ करना होगा ... = impl Trait पसंद करने का एक अच्छा कारण, मुझे लगता है! ईमानदारी से, अगर लोगों को लगता है कि प्रतिस्थापन के बारे में अंतर्ज्ञान यहां अस्तित्व के प्रकारों के लिए पर्याप्त रूप से टूट जाता है (सरल प्रकार के उपनामों की तुलना में), तो निम्नलिखित समझौता क्यों नहीं?

exists type Foo = (impl Bar, impl Baz);

(ईमानदारी से हालांकि, मुझे हर चीज के लिए सिंगल type कीवर्ड का उपयोग करने की निरंतरता चाहिए।)

मुझे लगता है:

exists type Foo: (Foo1, Foo2);

गहरा अजीब। Foo: (Foo1, Foo2) का उपयोग करना जहां RHS बाध्य नहीं है, भाषा में कहीं और Ty: Bound का उपयोग करने के तरीके के अनुरूप नहीं है।

निम्नलिखित रूप मुझे ठीक लगते हैं:

exists type Foo: Bar + Baz;  // <=> "There exists a type Foo which satisfies Bar and Baz."
                             // Reads super well!

type Foo = impl Bar + Baz;

type Bar = (impl Foo, impl Bar);

मैं यहां एक शब्द के रूप में abstract उपयोग नहीं करना भी पसंद करता हूं।

मुझे exists type Foo: (Foo1, Foo2); बहुत अजीब लगता है

यह निश्चित रूप से मेरे लिए एक गलती की तरह दिखता है, और मुझे लगता है कि इसे type Foo = (Foo1, Foo2); कहना चाहिए।

अगर हम यहां abstract type बनाम exists type बाइक शेडिंग कर रहे हैं, तो मैं निश्चित रूप से पूर्व का समर्थन करूंगा। अधिकतर क्योंकि "सार" विशेषण के रूप में काम करता है। मैं बातचीत में आसानी से कुछ "अमूर्त प्रकार" कह सकता हूं, जबकि यह कहना अजीब लगता है कि हम "अस्तित्व प्रकार" बना रहे हैं।

मैं अब भी : Foo + Bar से : (Foo, Bar) , = Foo + Bar , = impl Foo + Bar या = (impl Foo, impl Bar पसंद करूंगा। + का उपयोग अन्य सभी स्थानों के साथ अच्छी तरह से काम करता है, और = की कमी वास्तव में दर्शाती है कि हम पूर्ण प्रकार नहीं लिख सकते हैं। हम यहां एक प्रकार का उपनाम नहीं बना रहे हैं, हम उस चीज़ के लिए एक नाम बना रहे हैं जिसकी हम निश्चित सीमा की गारंटी देते हैं, लेकिन हम स्पष्ट रूप से नाम नहीं दे सकते।

मुझे अभी भी https://github.com/rust-lang/rfcs/pull/2071#issuecomment -318852774 का सिंटैक्स सुझाव पसंद है:

type ExistentialFoo: Bar;
type Bar: Baz + Bax;

हालांकि यह है, जैसा कि उस सूत्र में बताया गया है, थोड़ा बहुत अंतर है और बहुत स्पष्ट नहीं है।

मुझे आप में से कुछ लोगों से बहुत अलग तरीके से (impl Foo, impl Bar) व्याख्या करनी चाहिए ... मेरे लिए, इसका मतलब है कि प्रकार कुछ अस्तित्वगत प्रकारों का 2-टुपल है, और impl Foo + Bar से बिल्कुल अलग है।

@alexreg अगर वह @cramertj का इरादा था, तो मुझे अभी भी : सिंटैक्स के साथ यह बहुत अजीब लगेगा:

exists type Foo: (Foo1, Foo2);

यह अभी भी बहुत अस्पष्ट लगता है कि यह क्या कर रहा है - सीमाएं आमतौर पर किसी भी मामले में संभावित प्रकारों का एक टपल निर्दिष्ट नहीं करती हैं, और इसे आसानी से Foo: Foo1 + Foo2 सिंटैक्स के अर्थ के लिए भ्रमित किया जा सकता है।

= (impl Foo, impl Bar) एक दिलचस्प विचार है - ऐसे प्रकारों के साथ अस्तित्वपरक टुपल्स बनाने की अनुमति देना जो स्वयं ज्ञात नहीं हैं, दिलचस्प होगा। मुझे नहीं लगता कि हम _need_ उन लोगों का समर्थन करते हैं, क्योंकि हम केवल दो अस्तित्वगत प्रकारों को impl Foo और impl Bar लिए पेश कर सकते हैं, फिर टपल के लिए तीसरे प्रकार के उपनाम।

@daboross ठीक है, आप एक "अस्तित्ववादी प्रकार" बना रहे हैं, न कि "मौजूद प्रकार" ; जिसे टाइप थ्योरी में कहा जाता है। लेकिन मुझे लगता है कि वाक्यांश "एक प्रकार फू मौजूद है जो ..." मानसिक मॉडल और एक प्रकार के सैद्धांतिक परिप्रेक्ष्य से अच्छी तरह से काम करता है।

मुझे नहीं लगता कि हमें उनका समर्थन करने की आवश्यकता है, क्योंकि हम केवल impl Foo और impl Bar लिए दो अस्तित्वगत प्रकारों को पेश कर सकते हैं, फिर टपल के लिए तीसरे प्रकार के उपनाम।

ऐसा लगता है कि अनौपचारिक ... अस्थायी इतने अच्छे आईएमओ नहीं हैं।

@alexreg नोट: मेरे कहने का मतलब यह नहीं था कि impl Bar + Baz; (impl Foo, impl Bar) जैसा ही है, बाद वाला स्पष्ट रूप से 2-टुपल है।

@daboross

अगर वह @cramertj का इरादा था, तो मुझे अभी भी : वाक्यविन्यास के साथ यह बहुत अजीब लगेगा:

exists type Foo: (Foo1, Foo2);

यह अभी भी बहुत अस्पष्ट लगता है कि यह क्या कर रहा है - सीमाएं आमतौर पर किसी भी मामले में संभावित प्रकारों का एक टपल निर्दिष्ट नहीं करती हैं, और इसे आसानी से फू के अर्थ के लिए भ्रमित किया जा सकता है: फू 1 + फू 2 वाक्यविन्यास।

यह शायद थोड़ा अस्पष्ट है ( (impl Foo, impl Bar) जितना स्पष्ट नहीं है, जिसे मैं सहज रूप से तुरंत समझूंगा) - लेकिन मुझे नहीं लगता कि मैं इसे व्यक्तिगत रूप से Foo1 + Foo2 लिए कभी भ्रमित करूंगा।

= (इम्प्ल फू, इम्प्ला बार) एक दिलचस्प विचार है - ऐसे प्रकारों के साथ अस्तित्वपरक टुपल्स बनाने की अनुमति देना जो स्वयं ज्ञात नहीं हैं, दिलचस्प होगा। मुझे नहीं लगता कि हमें उन लोगों का समर्थन करने की ज़रूरत है, क्योंकि हम केवल दो अस्तित्व के प्रकारों को इंप्लांट फू और इम्प्ला बार के लिए पेश कर सकते हैं, फिर टुपल के लिए तीसरे प्रकार के उपनाम।

हाँ, यह एक प्रारंभिक प्रस्ताव था, और मुझे अब भी यह बहुत पसंद है। यह ध्यान दिया गया है कि यह वर्तमान सिंटैक्स का उपयोग करके वैसे भी किया जा सकता है, लेकिन इसके लिए कोड की 3 पंक्तियों की आवश्यकता होती है, जो कि बहुत ही एर्गोनोमिक नहीं है। मैं यह भी मानता हूं कि कुछ सिंटैक्स जैसे ... = (impl Foo, impl Bar) उपयोगकर्ता के लिए सबसे स्पष्ट है, लेकिन मुझे पता है कि यहां विवाद है।

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

ओह, मेरा संपादन https://github.com/rust-lang/rust/issues/34511#issuecomment -386763340 पर exists type Foo: (Foo1, Foo2); होना चाहिए था type Foo = (Foo1, Foo2); ।

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

type A = impl Foo;
type B = (impl Foo, impl Bar, String);

@alexreg हाँ, मुझे लगता है कि सबसे ergonomic वाक्य रचना है लगता है।

RFC https://github.com/rust-lang/rfcs/pull/2289 का उपयोग करके, मैं इस प्रकार @cramertj के स्निपेट को फिर से

type Foo = (impl Bar, impl Baz);
type IterDisplay = impl Iterator<Item: Display>;

// alternatively:

exists type IterDisplay: Iterator<Item: Display>;

type IterDisplay: Iterator<Item: Display>;

हालांकि, मुझे लगता है कि टाइप उपनामों के लिए, exists पेश नहीं करने से भाषा के सिंटैक्स को और अधिक जटिल बनाते हुए अभिव्यंजक शक्ति बनाए रखने में मदद मिलेगी; इसलिए जटिल बजट पीओवी से, impl Iterator exists से बेहतर लगता है। अंतिम विकल्प वास्तव में नए सिंटैक्स का परिचय नहीं देता है और स्पष्ट होने के साथ-साथ सबसे छोटा भी है।

संक्षेप में, मुझे लगता है कि निम्नलिखित दोनों रूपों की अनुमति दी जानी चाहिए (क्योंकि यह impl Trait और हमारे पास पहले से मौजूद संबंधित प्रकार के सिंटैक्स पर सीमा दोनों के तहत काम करता है):

type Foo = (impl Bar, impl Baz);
type IterDisplay: Iterator<Item: Display>;

संपादित करें: किस वाक्यविन्यास का उपयोग किया जाना चाहिए? आईएमओ, क्लीपी को स्पष्ट रूप से Type: Bound सिंटैक्स पसंद करना चाहिए जब इसका उपयोग करना संभव हो क्योंकि यह सबसे एर्गोनोमिक और प्रत्यक्ष है।

मुझे type Foo: Trait वैरिएंट की तुलना में type Foo = impl Trait वैरिएंट अधिक पसंद है। यह संबंधित प्रकार के सिंटैक्स से मेल खाता है, जो अच्छा है क्योंकि यह उस मॉड्यूल का "आउटपुट प्रकार" भी है जिसमें यह शामिल है।

impl Trait सिंटैक्स का उपयोग पहले से ही इनपुट और आउटपुट दोनों प्रकारों के लिए किया जाता है, जिसका अर्थ है कि यह पॉलीमॉर्फिक मॉड्यूल की छाप देने का जोखिम उठाता है। :(

यदि impl Trait का उपयोग केवल आउटपुट प्रकारों के लिए किया जाता है, तो मैं type Foo = impl Trait संस्करण को इस आधार पर पसंद कर सकता हूं कि संबंधित प्रकार सिंटैक्स लक्षणों के लिए अधिक है (जो कि एमएल हस्ताक्षरों के अनुरूप है) जबकि type Foo = .. कंक्रीट मॉड्यूल के लिए

@rpjohnst

मुझे type Foo: Trait वैरिएंट की तुलना में type Foo = impl Trait वैरिएंट अधिक पसंद है।

मैं सहमत हूं, जब भी संभव हो इसका उपयोग किया जाना चाहिए; लेकिन (impl T, impl U) के मामले के बारे में क्या है जहां बाध्य वाक्यविन्यास सीधे उपयोग नहीं किया जा सकता है? मुझे ऐसा लगता है कि अस्थायी प्रकार के उपनामों को पेश करने से पठनीयता प्रभावित होती है।

केवल type Name: Bound का उपयोग करना ऐसा लगता है जैसे impl ब्लॉक के अंदर उपयोग किए जाने पर यह भ्रमित हो जाएगा:

impl Iterator for Foo {
    type Item: Display;

    fn next(&mut self) -> Option<Self::Item> { Some(5) }
}

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

pub abstract type First: Display;
pub abstract type Second: Debug;

impl Iterator for Foo {
    type Item = (First, Second);

    fn next(&mut self) -> Option<Self::Item> { Some((5, 6)) }
}

बनाम

impl Iterator for Foo {
    type Item = (impl Display, impl Debug);

    fn next(&mut self) -> Option<Self::Item> { Some((5, 6)) }
}

@ Nemo157 दोनों को अनुमति क्यों न दें:

pub type First: Display;
pub type Second: Debug;

impl Iterator for Foo {
    type Item = (First, Second);
    fn next(&mut self) -> Option<Self::Item> { Some((5, 6)) }
}

तथा:

impl Iterator for Foo {
    type Item = (impl Display, impl Debug);
    fn next(&mut self) -> Option<Self::Item> { Some((5, 6)) }
}

?

मैं नहीं देखता कि एक ही सुविधा के लिए दो सिंटैक्स होने की आवश्यकता क्यों है, केवल type Name = impl Bound; सिंटैक्स का उपयोग करके स्पष्ट रूप से दो भागों के लिए नाम प्रदान करना अभी भी संभव होगा:

pub type First = impl Display;
pub type Second = impl Debug;

impl Iterator for Foo {
    type Item = (First, Second);
    fn next(&mut self) -> Option<Self::Item> { Some((5, 6)) }
}

@ निमो157 मैं मानता हूं कि दो अलग-अलग वाक्यविन्यास होने की आवश्यकता नहीं है (और नहीं)। हालांकि, मुझे कहना होगा कि मुझे type (बिना किसी उपसर्ग कीवर्ड के) भ्रमित करने वाला नहीं लगता।

@rpjohnst एक बहुरूपी मॉड्यूल बिल्ली क्या है? :-) वैसे भी, मुझे नहीं लगता कि हमें संबंधित प्रकार की परिभाषाओं के बाद सिंटैक्स का मॉडलिंग क्यों करना चाहिए, जो एक प्रकार पर विशेषता सीमाएं रख रहे हैं। इसका सीमा से कोई लेना-देना नहीं है।

@alexreg एक fn foo(x: impl Trait) करता है। यह ऐसा कुछ नहीं है जो मौजूद है, और इसलिए मैं नहीं चाहता कि लोग यह सोचें कि यह करता है।

abstract type ( संपादित करें: फीचर को नाम देने के लिए, कीवर्ड के उपयोग का सुझाव देने के लिए नहीं) सब कुछ सीमा से संबंधित है! बाउंड केवल एक चीज है जिसे आप प्रकार के बारे में जानते हैं। उनके और संबद्ध प्रकारों के बीच एकमात्र अंतर यह है कि उनका अनुमान लगाया जाता है, क्योंकि वे आमतौर पर अनाम होते हैं।

@ Nemo157 Foo: Bar सिंटैक्स अन्य संदर्भों में पहले से ही अधिक परिचित है (संबंधित प्रकारों पर सीमाएं, और प्रकार पैरामीटर पर) और अधिक एर्गोनोमिक और (आईएमओ) स्पष्ट है जब इसे अस्थायी पेश किए बिना उपयोग किया जा सकता है।

लिखना:

type IterDisplay: Iterator<Item: Display>;

एक पूरी बहुत अधिक प्रत्यक्ष wrt लगता है। की तुलना में मैं क्या कहना चाहता हूं

type IterDisplay = impl Iterator<Item = impl Display>;

मुझे लगता है कि यह हमारे पास पहले से मौजूद सिंटैक्स को लगातार लागू कर रहा है; तो यह वास्तव में नया नहीं है।

EDIT2: पहला सिंटैक्स यह भी है कि मैं इसे रस्टडॉक में कैसे प्रस्तुत करना चाहता हूं।

एक ऐसे गुण से जाना जिसके लिए किसी संबद्ध प्रकार पर किसी चीज़ की आवश्यकता होती है, एक निहितार्थ के लिए भी वास्तव में आसान हो जाता है:

trait Foo {
    type Bar: Baz;
    // stuff...
}

struct Quux;

impl Foo for Quux {
    type Bar: Baz; // Oh look! Same as in the trait; I had to do nothing!
    // stuff...
}

impl Bar सिंटैक्स बेहतर लगता है जब आपको अन्यथा अस्थायी परिचय देना होगा, लेकिन यह सिंटैक्स को लगातार लागू कर रहा है।

दोनों सिंटैक्स का उपयोग करने में सक्षम होना वास्तव में तर्क स्थिति में impl Trait का उपयोग करने में सक्षम होने के साथ-साथ एक स्पष्ट प्रकार पैरामीटर T: Trait होने से बहुत अलग नहीं होगा जिसका उपयोग तर्क द्वारा किया जाता है।

EDIT1: वास्तव में, केवल एक सिंटैक्स का होना विशेष आवरण होगा, न कि दूसरी तरफ।

@rpjohnst मैं अलग होने की भीख माँगता हूँ, हालाँकि मुझे यह कहना चाहिए था कि इसका स्पष्ट रूप से सीमा से कोई लेना-देना नहीं है।

वैसे भी, मैं type Foo: Bar; वाक्यविन्यास के खिलाफ नहीं हूं, लेकिन भलाई के लिए, आइए abstract कीवर्ड से छुटकारा पाएं। किसी भी परिस्थिति में type अपने आप में बिल्कुल स्पष्ट है।

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

साथ ही, यह मानते हुए कि मुझे type Iter: Iterator<Item = Foo> मुझे Foo ढूंढना होगा और यह पता लगाना होगा कि क्या हो रहा है इससे पहले कि यह एक प्रकार या विशेषता है।

और अंत में, मुझे लगता है कि अनुमान बिंदुओं का दृश्य सुराग अनुमान त्रुटियों को डीबग करने और अनुमान त्रुटि संदेशों की व्याख्या करने में भी मदद करेगा।

तो मुझे लगता है कि = / impl संस्करण थोड़ा और पेपरकट हल करता है।

@फायलॉन

साथ ही, मान लीजिए कि मुझे टाइप Iter: Iterator<Item = Foo> मुझे Foo ढूंढना होगा और यह पता लगाना होगा कि यह क्या हो रहा है, इससे पहले कि यह एक प्रकार या विशेषता है।

यह मुझे नहीं मिलता है; Item = Foo हमेशा एक प्रकार होना चाहिए, यह देखते हुए कि dyn Foo स्थिर है (और नंगे लक्षण चरणबद्ध हो रहे हैं ...)?

@सेंट्रिल

यह मुझे नहीं मिलता है; आइटम = फू हमेशा एक प्रकार का होना चाहिए, यह देखते हुए कि dyn फू स्थिर है (और नंगे लक्षण चरणबद्ध हो रहे हैं ...)?

हाँ, लेकिन प्रस्तावित impl कम संस्करण में, यह एक बाध्य, या एक ठोस प्रकार के साथ एक अनुमानित प्रकार हो सकता है। जैसे Iterator<Item = String> बनाम Iterator<Item = Display> । मुझे यह जानने के लिए लक्षणों को जानना होगा कि क्या अनुमान हो रहा है।

संपादित करें: आह, किसी ने : उपयोग नहीं किया। किंडा मेरा मतलब है याद करने में आसान :) लेकिन आप सही हैं कि वे अलग हैं।

2 संपादित करें: मुझे लगता है कि यह समस्या संबद्ध प्रकारों के बाहर होगी। type Foo: (Bar, Baz) को देखते हुए आपको यह जानने के लिए बार और बाज को जानना होगा कि अनुमान कहाँ होता है।

@सेंट्रिल

EDIT1: वास्तव में, केवल एक सिंटैक्स का होना विशेष आवरण होगा, न कि दूसरी तरफ।

वर्तमान में _existential_ प्रकार, -> impl Trait घोषित करने का केवल एक ही तरीका है। तर्क सूची में _universal_ प्रकार ( T: Trait और : impl Trait ) घोषित करने के दो तरीके हैं।

यदि हमारे पास बहुरूपी मॉड्यूल थे जो सार्वभौमिक प्रकारों में लेते थे, तो मैं उसके आस-पास कुछ तर्क देख सकता था, लेकिन मेरा मानना ​​​​है कि दोनों मॉड्यूल और विशेषता परिभाषाओं में type Name = Type; का वर्तमान उपयोग आउटपुट प्रकार पैरामीटर के रूप में है, जो एक अस्तित्वगत होना चाहिए प्रकार।

@फायलॉन

हाँ, लेकिन प्रस्तावित impl कम संस्करण में, यह एक बाध्य, या एक ठोस प्रकार के साथ एक अनुमानित प्रकार हो सकता है। जैसे Iterator<Item = String> बनाम Iterator<Item = Display> । मुझे यह जानने के लिए लक्षणों को जानना होगा कि क्या अनुमान हो रहा है।

मेरा मानना ​​है कि impl कम संस्करण अस्तित्वगत प्रकारों के लिए सभी मामलों में : Bound का उपयोग कर रहा है, इसलिए आपके पास विशेषता सीमा के रूप में Iterator<Item = String> या Iterator<Item: Display> , लेकिन Iterator<Item = Display> एक अमान्य घोषणा होगी।

@ निमो157
आप संबंधित प्रकार के मामले के संबंध में सही हैं, मेरा वहां बुरा है। लेकिन (जैसा कि मेरे संपादन में उल्लेख किया गया है) मुझे लगता है कि अभी भी type Foo: (A, B) साथ कोई समस्या है। जैसा कि A या B एक प्रकार या विशेषता हो सकता है।

मेरा मानना ​​है कि = साथ जाने का यह भी एक अच्छा कारण है। : केवल आपको बताता है कि कुछ चीजें अनुमानित हैं, लेकिन आपको यह नहीं बताती हैं कि कौन सी है। type Foo = (A, impl B) मुझे स्पष्ट लगता है।

मैं यह भी मानता हूं कि impl साथ कोड स्निपेट पढ़ना और प्रदान करना आसान है, क्योंकि एक विशेषता क्या है और क्या नहीं है इसके बारे में अतिरिक्त संदर्भ प्रदान करने की आवश्यकता नहीं है।

संपादित करें: कुछ क्रेडिट: मेरा तर्क मूल रूप से @alexreg के यहाँ जैसा ही impl बेहतर है।

वर्तमान में अस्तित्वगत प्रकार घोषित करने का केवल एक ही तरीका है, -> impl Trait । सार्वभौमिक प्रकार घोषित करने के दो तरीके हैं ( T: Trait और : impl Trait एक तर्क सूची में)।

मैं यही कह रहा हूं: पीआई सार्वभौमिक परिमाणीकरण के दो तरीके क्यों होने चाहिए, लेकिन अन्य स्थानों पर केवल एक ही अस्तित्व में है ( dyn Trait अनदेखी)?

यह मेरे लिए समान रूप से संभावित लगता है कि कोई उपयोगकर्ता type Foo: Bound; और type Foo = impl Bound; भाषा के विभिन्न भागों को सीखने के बाद लिखेगा, और मैं यह नहीं कह सकता कि सभी मामलों में एक वाक्यविन्यास स्पष्ट रूप से बेहतर है; मेरे लिए यह स्पष्ट है कि एक वाक्य रचना कुछ चीजों के लिए बेहतर है और दूसरी विभिन्न चीजों के लिए।

@फायलॉन

मेरा मानना ​​है कि = के साथ जाने का यह भी एक अच्छा कारण है। : केवल आपको बताता है कि कुछ चीजें अनुमानित हैं, लेकिन आपको यह नहीं बताती हैं कि कौन सी है। टाइप फू = (ए, इंप बी) मुझे स्पष्ट लगता है।

हाँ, यह शायद एक और अच्छा कारण है। यह वास्तव में कुछ अनपैकिंग लेता है यह पता लगाने के लिए कि क्या अस्तित्वगत रूप से परिमाणित किया जा रहा है - परिभाषा से परिभाषा तक कूदना।

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

type A: Foo;
type B: Bar;
type C: Baz;
type D: Iterator<Item = C>; 
type E = (A, Vec<B>, D);

सिंटैक्स का उपयोग करना जिसे मैं (और यहां कुछ अन्य) पसंद करते हैं, हम यह सब एक ही पंक्ति में लिख सकते हैं, और इसके अलावा यह तुरंत स्पष्ट हो जाता है कि परिमाणीकरण कहाँ हो रहा है!

type E = (impl Foo, Vec<impl Bar>, impl Iterator<Item = impl Baz>);

उपरोक्त से असंबंधित: हम रात में let x: impl Trait को लागू करने के लिए कब खेलते हैं? मैं कुछ समय से इस सुविधा को याद कर रहा हूं।

@alexreg

एक और बात यह है: क्या कोई उस सिंटैक्स के तहत : को एक संबद्ध प्रकार के बंधन के भीतर भी अनुमति देगा?

हाँ क्यों नहीं; यह rust-lang/rfcs#2289 + type Foo: Bound स्वाभाविक प्रभाव होगा।

आप यह भी कर सकते हैं:

type E = (impl Foo, Vec<impl Bar>, impl Iterator<Item: Baz>);

@Centril मुझे लगता है कि दो वैकल्पिक वाक्यविन्यासों को अनुमति देना एक बुरा विचार है। "हम तय नहीं कर सके, इसलिए हम दोनों का समर्थन करेंगे" सिंड्रोम जैसी गंध आती है। कोड को देखना जो उन्हें मिलाता है और मेल खाता है, एक वास्तविक आंखों की रोशनी होगी!

@Centril मैं आपके BTW के उस RFC पर @nikomatsakis के साथ हूँ, क्षमा करें। बल्कि लिखेंगे impl Iterator<Item = impl Baz> । अच्छा और स्पष्ट।

@alexreg यह उचित है;

लेकिन (संयुक्त राष्ट्र) सौभाग्य से (आपके पीओवी के आधार पर), हमने पहले से ही तर्क स्थिति में impl Trait साथ "दो वैकल्पिक सिंटैक्स की अनुमति दें" शुरू कर दी है, जैसे कि हमारे पास Foo: Bar और impl Bar एक ही बात का मतलब काम करना;

यह सार्वभौमिक परिमाणीकरण के लिए है, लेकिन impl Trait अंकन वास्तव में इस बात की परवाह नहीं करता है कि यह द्वैत के किस पक्ष पर है; आखिरकार, हम any Trait और some Trait ।

यह देखते हुए कि हमने पहले से ही "हम तय नहीं कर सके" और "द्वैत का पक्ष वाक्य-विन्यास से कोई फर्क नहीं पड़ता " का चुनाव कर लिया है, यह मुझे हर जगह "हम तय नहीं कर सकते" लागू करने के लिए सुसंगत लगता है ताकि उपयोगकर्ता को न मिले में "लेकिन मैं इसे वहाँ इस तरह लिख सकता था, यहाँ क्यों नहीं?" ;)

पुनश्च:

पुनः। impl Iterator<Item = impl Baz> यह जहां क्लॉज में बाउंड के रूप में काम नहीं करता है; तो आपको इसे Iter: Iterator<Item = impl Baz> तरह मिलाना होगा। आपको इसकी अनुमति देनी होगी: Iter = impl Iterator<Item = impl Baz> इसके लिए समान रूप से काम करने के लिए (शायद हमें चाहिए?)।

का उपयोग करते हुए : Bound भी के बजाय है = impl Bound , यह भी स्पष्ट है सिर्फ छोटे ^, -
मुझे लगता है कि X = Ty और X: Ty बीच अंतर में अंतर वाक्य रचना को सुपाठ्य बनाता है।

मेरी अपनी सलाह को नज़रअंदाज़ करने के बाद, आइए RFC में इस बातचीत को जारी रखें;)

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

हमने किया, लेकिन मेरा मानना ​​है कि चुनाव समरूपता/संगति के दृष्टिकोण से अधिक किया गया था। सामान्य रूप से टाइप किए गए तर्क सार्वभौमिक रूप से टाइप किए गए ( impl Trait ) वाले तर्कों की तुलना में सख्ती से अधिक शक्तिशाली होते हैं। लेकिन हम वापसी की स्थिति में impl Trait पेश कर रहे थे, इसे तर्क स्थिति पेश करना समझ में आया।

यह देखते हुए कि हमने पहले से ही "हम तय नहीं कर सके" और "द्वैत का पक्ष वाक्य-विन्यास से कोई फर्क नहीं पड़ता" का चुनाव कर लिया है, यह मुझे हर जगह "हम तय नहीं कर सकते" लागू करने के लिए सुसंगत लगता है ताकि उपयोगकर्ता को न मिले में "लेकिन मैं इसे वहाँ इस तरह लिख सकता था, यहाँ क्यों नहीं?" ;)

मुझे यकीन नहीं है कि यह उस बिंदु पर है जहां हमें अपनी बाहों को ऊपर उठाना चाहिए और कहना चाहिए "चलो सब कुछ लागू करें"। यहाँ लाभ के बारे में उतना स्पष्ट तर्क नहीं है।

पुनश्च:

पुनः। impl Iterator<Item = impl Baz> यह जहां क्लॉज में बाउंड के रूप में काम नहीं करता है; तो आपको इसे Iter: Iterator<Item = impl Baz> तरह मिलाना होगा। आपको इसकी अनुमति देनी होगी: Iter = impl Iterator<Item = impl Baz> इसके लिए समान रूप से काम करने के लिए (शायद हमें चाहिए?)।

मैं कहूंगा कि हम या तो केवल where Iter: Iterator<Item = T>, T: Baz समर्थन करते हैं (जैसे हमारे पास अभी है) या Iter = impl Iterator<Item = impl Baz> (जैसा आपने सुझाव दिया) के साथ पूरी तरह से जाना। केवल आधे-अधूरे घर को अनुमति देना पुलिस-आउट जैसा लगता है।

का उपयोग करते हुए : Bound भी के बजाय है = impl बाउंड, यह भी स्पष्ट है सिर्फ छोटे ^, -
मुझे लगता है कि X = Ty और X: Ty बीच अंतर में अंतर वाक्य रचना को सुपाठ्य बनाता है।

यह सुपाठ्य है, लेकिन मुझे नहीं लगता कि यह लगभग स्पष्ट/स्पष्ट है कि अस्तित्व के प्रकार का उपयोग किया जा रहा है। यह तब और बढ़ जाता है जब इस सिंटैक्स की सीमा के कारण परिभाषा को कई पंक्तियों में विभाजित करना पड़ता है।

मेरी अपनी सलाह को नज़रअंदाज़ करने के बाद, आइए RFC में इस बातचीत को जारी रखें;)

रुको, तुम्हारा मतलब है आपका RFC? मुझे लगता है कि यह उस और इस दोनों के लिए प्रासंगिक है, जो मैं बता सकता हूं। :-)

रुको, तुम्हारा मतलब है आपका RFC? मुझे लगता है कि यह उस और इस दोनों के लिए प्रासंगिक है, जो मैं बता सकता हूं। :-)

ठीक है; चलो फिर यहीं चलते हैं;

हमने किया, लेकिन मेरा मानना ​​है कि चुनाव समरूपता/संगति के दृष्टिकोण से अधिक किया गया था। सामान्य रूप से टाइप किए गए तर्क सार्वभौमिक रूप से टाइप किए गए ( impl Trait ) वाले तर्कों की तुलना में सख्ती से अधिक शक्तिशाली होते हैं। लेकिन हम वापसी की स्थिति में impl Trait पेश कर रहे थे, इसे तर्क स्थिति पेश करना समझ में आया।

मेरा पूरा बिंदु निरंतरता और समरूपता के बारे में है। = पी
यदि आपको अस्तित्वगत और सार्वभौमिक परिमाणीकरण दोनों के लिए impl Trait लिखने की अनुमति है, तो मेरे लिए यह समझ में आता है कि आपको सार्वभौमिक और अस्तित्वगत परिमाणीकरण दोनों के लिए Type: Trait का उपयोग करने की अनुमति दी जानी चाहिए।

अभिव्यंजक शक्ति के संबंध में, जैसा कि आप कहते हैं, पूर्व उत्तरार्द्ध की तुलना में अधिक शक्तिशाली है, लेकिन जरूरी नहीं कि ऐसा ही हो; वे समान रूप से शक्तिशाली हो सकते हैं यदि हम चाहते हैं कि वे AFAIK हों (मैं बिल्कुल नहीं कह रहा हूं कि हमें ऐसा करना चाहिए ..)।

fn foo(bar: impl Trait, baz: typeof bar) { // eww... but possible!
    ...
}

मुझे यकीन नहीं है कि यह उस बिंदु पर है जहां हमें अपनी बाहों को ऊपर उठाना चाहिए और कहना चाहिए "चलो सब कुछ लागू करें"। यहाँ लाभ के बारे में उतना स्पष्ट तर्क नहीं है।

मेरा तर्क यह है कि आश्चर्यजनक उपयोगकर्ता "यह वाक्यविन्यास कहीं और प्रयोग योग्य है और इसका अर्थ यहां स्पष्ट है, लेकिन आप इसे इस जगह पर नहीं लिख सकते हैं" इसे करने के दो तरीकों से अधिक खर्च होता है (जिसे आप दोनों को किसी भी तरह से खुद को परिचित करना होगा ) हमने https://github.com/rust-lang/rfcs/pull/2300 (विलय), https://github.com/rust-lang/rfcs/pull/2302 (PFCP), https के साथ भी ऐसा ही किया है।

यह सुपाठ्य है, लेकिन मुझे नहीं लगता कि यह लगभग स्पष्ट/स्पष्ट है कि अस्तित्व के प्रकार का उपयोग किया जा रहा है।

मेरे विचार से सुपाठ्य पर्याप्त है; मुझे नहीं लगता कि रस्ट "सबसे ऊपर स्पष्ट" के लिए जिम्मेदार है और अत्यधिक वर्बोज़ होने के नाते (जो मुझे बहुत अधिक उपयोग किए जाने पर सिंटैक्स मिलता है) भी उपयोग को हतोत्साहित करके खर्च होता है।
(यदि आप चाहते हैं कि कुछ अक्सर इस्तेमाल किया जाए, तो इसे टेरसर सिंटैक्स दें ... cf ? रिश्वत के रूप में .unwrap() )।

यह तब और बढ़ जाता है जब इस सिंटैक्स की सीमा के कारण परिभाषा को कई पंक्तियों में विभाजित करना पड़ता है।

यह मुझे नहीं मिलता है; मुझे ऐसा लगता है कि Assoc = impl Trait लाइन विभाजन का कारण Assoc: Trait से भी अधिक होना चाहिए क्योंकि पूर्व लंबा है।

मैं कहूंगा कि हम या तो केवल where Iter: Iterator<Item = T>, T: Baz समर्थन करते हैं (जैसे हमारे पास अभी है) या Iter = impl Iterator<Item = impl Baz> (जैसा आपने सुझाव दिया) के साथ पूरी तरह से जाना।
केवल आधे-अधूरे घर को अनुमति देना पुलिस-आउट जैसा लगता है।

बिल्कुल सही!, चलो आधे रास्ते घर/पुलिस-आउट नहीं जाते हैं और where Iter: Iterator<Item: Baz> ;)

@Centril ठीक है, आपने मुझे मुख्य रूप से समरूपता/स्थिरता तर्क पर जीत लिया है। दोनों रूपों के होने का एर्गोनॉमिक्स हालांकि भी मदद करता है। हालांकि, इस सुविधा के लिए लंबे समय से पहले भारी लाइनिंग जरूरी है।

कल मेरे पूरे उत्तर के साथ इसे संपादित करेंगे।

संपादित करें

जैसा कि @Centril बताता है, हम पहले से ही : Trait (बाध्य) सिंटैक्स का उपयोग करके सार्वभौमिक प्रकारों का समर्थन करते हैं। जैसे

fn foo<T: Trait>(x: T) { ... }

"उचित" या "संशोधित" सार्वभौमिक प्रकारों के साथ, उदा

fn foo(x: impl Trait) { ... }

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

अब, हमारे पास पहले से ही impl Trait फ़ंक्शन रिटर्न स्थिति में भी है, जो एक अस्तित्व प्रकार का प्रतिनिधित्व करता है। संबंधित प्रकार के लक्षण रूप में मौजूद हैं, और पहले से ही : Trait सिंटैक्स का उपयोग करते हैं।

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

type A: Iterator<Item: Foo + Bar>;
type B = (impl Baz, impl Debug, String);

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

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

struct Foo {
    pub foo: impl Display,
}

क्या यह अस्तित्वगत या सार्वभौमिक परिमाणीकरण के लिए आशुलिपि है? फ़ंक्शन हस्ताक्षरों में impl Trait का उपयोग करने से प्राप्त अंतर्ज्ञान से मैं नहीं देखता कि आप कैसे निर्णय ले सकते हैं। यदि आप वास्तव में इसे दोनों के रूप में उपयोग करने का प्रयास करते हैं, तो आप जल्दी से महसूस करेंगे कि इस स्थिति में अनाम सार्वभौमिक परिमाणीकरण बेकार है, इसलिए यह अस्तित्वगत परिमाणीकरण होना चाहिए, लेकिन यह फ़ंक्शन तर्कों में impl Trait साथ असंगत है।

ये दो मौलिक रूप से अलग-अलग ऑपरेशन हैं, हां वे दोनों विशेषता सीमाओं का उपयोग करते हैं, लेकिन मुझे कोई कारण नहीं दिखता है कि अस्तित्व के प्रकार को घोषित करने के दो तरीके नए लोगों के लिए भ्रम को कम करेंगे। यदि type Name: Trait का उपयोग करने का प्रयास वास्तव में नवागंतुकों के लिए एक संभावित चीज है तो इसे एक लिंट के माध्यम से हल किया जा सकता है:

    type Foo: Display;
    ^^^^^^^^^^^^^^^^^^
note: were you attempting to create an existential type?
note: suggested replacement `type Foo = impl Display`

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

मुझे लगता है कि मेरे पास RFC पर टिप्पणी करने के लिए अभी तक रस्ट के साथ पर्याप्त अनुभव नहीं है। हालाँकि, मुझे इस सुविधा को रात और स्थिर रस्ट में विलय होते देखने में दिलचस्पी है, ताकि ड्रॉप्स ऑफ़ डायमंड शार्डिंग कार्यान्वयन के हिस्से के रूप में Ethereum के लिए एक शार्डिंग प्रोटोकॉल बनाने के लिए सके । मैंने इस मुद्दे की सदस्यता ली है, हालांकि मेरे पास सभी टिप्पणियों को रखने के लिए समय नहीं है! मैं इस मुद्दे पर उच्च स्तर पर अप टू डेट कैसे रह सकता हूं, बिना पठन टिप्पणियों को स्किम किए?

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

मैं अब भी मानता हूं कि एक कीवर्ड के तहत सार्वभौमिक और अस्तित्वगत परिमाणीकरण को मिलाना एक गलती थी, और इसलिए कि स्थिरता तर्क मेरे लिए काम नहीं करता है।

एक सामान्य सिद्धांत के रूप में, इस विशेषता से स्वतंत्र, मुझे तर्क की यह पंक्ति समस्याग्रस्त लगती है।

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

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

आप मामला बना सकते हैं (लेकिन मैं ऐसा नहीं करूंगा):

struct Foo {
    pub foo: impl Display,
}

शब्दार्थ के बराबर है:

struct Foo<T: Display> {
    pub foo: T,
}

फ़ंक्शन-तर्क तर्क के तहत।

मूल रूप से, impl Trait , आपको यह सोचना होगा कि "क्या यह वापसी-प्रकार की तरह है, या तर्क जैसा है?" , जो मुश्किल हो सकता है।

यदि type Name: Trait का उपयोग करने का प्रयास वास्तव में नवागंतुकों के लिए एक संभावित चीज है तो इसे एक लिंट के माध्यम से हल किया जा सकता है:

मैं भी एक प्रकार का वृक्ष होगा, लेकिन दूसरी दिशा में; मुझे लगता है कि निम्नलिखित तरीके मुहावरेदार होने चाहिए:

// GOOD:
type Foo: Iterator<Item: Display>;

type Bar = (impl Display, impl Debug);

// BAD
type Foo = impl Iterator<Item = impl Display>;

type Bar0: Display;
type Bar1: Debug;
type Bar = (Bar0, Bar1);

ठीक है, वैकल्पिक सूत्रीकरण जो मेरा मानना ​​​​है कि RFC 2071 इशारा कर रहा है और इस मुद्दे पर चर्चा की जा सकती है, लेकिन कभी भी स्पष्ट रूप से नहीं कहा गया था:

अस्तित्वगत रूप से परिमाणित प्रकारों को घोषित करने के लिए केवल _one way_ है: existential type Name: Bound; ( existential का उपयोग करके क्योंकि यह RFC में निर्दिष्ट है, मैं पूरी तरह से इस फॉर्मूलेशन के तहत कीवर्ड को छोड़ने के खिलाफ नहीं हूं)।

वर्तमान दायरे में एक अज्ञात अस्तित्वगत रूप से मात्राबद्ध प्रकार को स्पष्ट रूप से घोषित करने के लिए अतिरिक्त चीनी है: impl Bound (समय के लिए फ़ंक्शन तर्कों में सार्वभौमिक मात्रा का ठहराव चीनी को अनदेखा करना)।

तो, वर्तमान रिटर्न प्रकार का उपयोग एक साधारण desugaring है:

fn foo() -> impl Iterator<Item = impl Display> { ... }

existential type _0: Display;
existential type _1: Iterator<Item = _0>;
fn foo() -> _1 { ... }

const , static और let करना समान रूप से तुच्छ है।

RFC में एक विस्तार का उल्लेख नहीं किया गया है: type Alias = Concrete; सिंटैक्स में इस चीनी का समर्थन करना, इसलिए जब आप लिखते हैं

type Foo = impl Iterator<Item = impl Display>;

यह वास्तव में चीनी है

existential type _0: Display;
existential type _1: Iterator<Item = _0>;
type Foo = _1;

जो तब मौजूदा मॉड्यूल को Foo माध्यम से देखने की अनुमति देने के लिए प्रकार के उपनामों की पारदर्शी प्रकृति पर निर्भर करता है और देखता है कि यह एक अस्तित्व के प्रकार को संदर्भित करता है।

वास्तव में, मेरा दृढ़ विश्वास है कि जहां संभव हो, हमारे पास बाद के रूप के पक्ष में एक कंपाइलर लिंट होना चाहिए।

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

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

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

तो... अब हम नामित अस्तित्व के प्रकारों के लिए वाक्य रचना पर काफी चर्चा कर चुके हैं। क्या हम किसी निष्कर्ष पर पहुंचने की कोशिश करेंगे और इसे आरएफसी/पीआर पोस्ट में लिखेंगे, ताकि कोई वास्तविक कार्यान्वयन पर काम शुरू कर सके? :-)

निजी तौर पर, एक बार जब हमने अस्तित्व का नाम दिया है, तो मैं कहीं भी impl Trait किसी भी उपयोग से दूर एक लिंट (यदि कोई हो) पसंद करूंगा।

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

क्या RFC impl Trait पर तर्क स्थिति में अद्यतित है? यदि हां, तो क्या यह बताना सुरक्षित है कि इसके शब्दार्थ _universal_ हैं? अगर ऐसा है: मैं रोना चाहता हूँ। गहराई से।

@फ़ाज़ोन : जंग 1.26 impl Trait लिए जारी नोट :

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

बस इसके बारे में अपने विचार व्यक्त करने के लिए:

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

मुझे सच में लगता है कि impl Trait तर्क की स्थिति में वर्तमान निर्णय एक दया है। :रोना:

मुझे सच में लगता है कि तर्क की स्थिति में निहित विशेषता वर्तमान निर्णय एक दया है। मैं

जबकि मैं इस पर थोड़ा फटा हुआ हूं, मुझे निश्चित रूप से लगता है कि अभी let x: impl Trait को लागू करने में समय बेहतर होगा!

सहसंयोजक अस्तित्व हमें रैंक-एन कार्यों के लिए द्वार खोलेंगे

हमारे पास इसके लिए पहले से ही एक सिंटैक्स है ( fn foo(f: impl for<T: Trait> Fn(T)) ), (उर्फ "टाइप एचआरटीबी"), लेकिन इसे अभी तक लागू नहीं किया गया है। fn foo(f: impl Fn(impl Trait)) एक त्रुटि उत्पन्न करता है कि "नेस्टेड impl Trait की अनुमति नहीं है", और मुझे उम्मीद है कि हम चाहते हैं कि इसका मतलब उच्च-रैंक संस्करण हो, जब हमें टाइप HRTB मिलता है।

यह उसी तरह है जैसे Fn(&'_ T) अर्थ है for<'a> Fn(&'a T) , इसलिए मुझे इसके विवादास्पद होने की उम्मीद नहीं है।

वर्तमान मसौदे को देखते हुए, तर्क स्थिति में impl Trait एक _universal_ है, लेकिन आप कह रहे हैं कि impl for<_> Trait इसे _existential_ में बदल देता है?! वह कितना पागल है?

हमने क्यों सोचा कि हमें _सार्वभौमिक_ बनाने के लिए _अभी तक एक और तरीका_ पेश करने की आवश्यकता है? मेरा मतलब है:

fn foo(x: impl MyTrait)

केवल दिलचस्प है क्योंकि अज्ञात प्रकार चर प्रकार में केवल एक बार प्रकट होता है । यदि आपको उसी प्रकार को वापस करने की आवश्यकता है:

fn foo(x: impl Trait) -> impl Trait

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

अर्घ, मुझे लगता है कि यह सब पहले ही स्वीकार कर लिया गया था और मैं बिना कुछ लिए शेखी बघार रहा हूं। मुझे लगता है कि यह एक वास्तविक दया है। मुझे पूरा यकीन है कि मैं आरएफसी के फैसले से निराश अकेला नहीं हूं।

(सुविधा के स्थिर होने के बाद शायद इस पर बहस करने का कोई मतलब नहीं है, लेकिन एक ठोस तर्क के लिए यहां देखें (जिससे मैं सहमत हूं) क्यों impl Trait तर्क की स्थिति में शब्दार्थ होने के कारण यह समझदार है और सुसंगत। टीएल; डॉ यह उसी कारण से है कि क्यों fn foo(arg: Box<Trait>) लगभग fn foo<T: Trait>(arg: Box<T>) के समान ही काम करता है, भले ही dyn Trait एक अस्तित्वगत है; अब dyn प्रतिस्थापित करें impl ।)

वर्तमान मसौदे को देखते हुए, तर्क स्थिति में impl Trait एक सार्वभौमिक है, लेकिन आप कह रहे हैं कि impl for<_> Trait इसे अस्तित्व में बदल देता है ?!

नहीं, वे दोनों सार्वभौमिक हैं। मैं कह रहा हूं कि उच्च-रैंक वाले उपयोग इस तरह दिखाई देंगे:

fn foo<F: for<G: Fn(X) -> Y> Fn(G) -> Z>(f: F) {...}

जो एक ही समय में जोड़ा जा सकता है (यानी impl Trait कोई बदलाव नहीं) के रूप में लिखा जा सकता है:

fn foo(f: impl for<G: Fn(X) -> Y> Fn(G) -> Z) {...}

यह सार्वभौमिक है impl Trait , बस यह कि Trait एक HRTB है ( impl for<'a> Fn(&'a T) )।
अगर हम तय करते हैं (जिसकी मुझे उम्मीद है) कि impl Trait अंदर Fn(...) तर्क भी सार्वभौमिक हैं, तो आप इसे उसी प्रभाव को प्राप्त करने के लिए लिख सकते हैं:

fn foo(f: impl Fn(impl Fn(X) -> Y) -> Z) {...}

मैंने सोचा कि आपका मतलब "उच्च-रैंकिंग" से है, अगर आपने नहीं किया, तो कृपया मुझे बताएं।

एक और अधिक दिलचस्प निर्णय अस्तित्व की स्थिति में एक ही उपचार को लागू करने के लिए हो सकता है, यानी इसे अनुमति देना (जिसका अर्थ होगा " कुछ बंद करना जो किसी अन्य बंद को लेता है"):

fn foo() -> impl for<G: Fn(X) -> Y> Fn(G) -> Z {...}

इस तरह लिखा जाना है:

fn foo() -> impl Fn(impl Fn(X) -> Y) -> Z {...}

यह एक अस्तित्वगत impl Trait जिसमें एक सार्वभौमिक impl Trait (संलग्न कार्य के बजाय अस्तित्व के लिए बाध्य) होगा।

@eddyb क्या सामान्य रूप से अस्तित्वगत और सार्वभौमिक शौक को भ्रमित न करने के लिए?
अस्तित्वगत परिमाणीकरण के लिए खोजशब्द भी अस्तित्वगत प्रकारों के लिए पुन: उपयोग योग्य नहीं होगा?
हम अस्तित्वगत ( और सार्वभौमिक) परिमाणीकरण के लिए impl का उपयोग क्यों कर रहे हैं लेकिन अस्तित्व के प्रकारों के लिए existential रहे हैं?

मैं तीन बिंदु बनाना चाहूंगा:

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

यह वास्तव में दुखद है कि यह प्रतिक्रिया स्थिरीकरण के बाद आती है और इस घटना के बारे में कुछ किया जाना चाहिए

जब तक यह एक विचार रहा है, तब तक तर्क की स्थिति में impl Trait आपत्तियां रही हैं। इस तरह की प्रतिक्रिया _नई नहीं है_, प्रासंगिक RFC थ्रेड में भी इस पर अत्यधिक बहस हुई थी। टाइप-थ्योरी के नजरिए से न केवल सार्वभौमिक/अस्तित्ववादी प्रकारों के बारे में बहुत चर्चा हुई, बल्कि यह भी कि नए उपयोगकर्ताओं के लिए यह कैसे भ्रमित होगा।

सच है, हमें वास्तविक नए उपयोगकर्ताओं के दृष्टिकोण नहीं मिले, लेकिन यह कहीं से भी नहीं निकला।

@Boscop any और some को इस काम को करने के लिए कीवर्ड की एक जोड़ी के रूप में प्रस्तावित किया गया था, लेकिन इसके खिलाफ फैसला किया गया था (हालांकि मुझे नहीं पता कि तर्क कहीं भी लिखा गया था)।

सच है, हमें रस्ट में नए लोगों से प्रतिक्रिया नहीं मिली और जो सिद्धांतवादी टाइप नहीं थे

और समावेश के लिए तर्क हमेशा यह था कि इससे नए लोगों के लिए यह आसान हो जाएगा। इसलिए यदि हमारे पास अब नवागंतुकों से प्रासंगिक प्रतिक्रिया नहीं होनी चाहिए?

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

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

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

जैसा कि आपने कहा था कि फीडबैक पर मेटा चर्चा कहीं और करना बेहतर है, हालांकि मुझे यकीन नहीं है कि यह कहां होगा।

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

ज़्यादा बुरा? ऐसा कैसे? मैं अस्पष्टता/भ्रम से अधिक याद रखना पसंद करता हूं।

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

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

अब इसे पेश किया गया था और हमारे पास वास्तविक हार्ड डेटा प्राप्त करने का एक तरीका है, या किसी भी हार्ड डेटा के रूप में प्राप्त किया जा सकता है कि लोग 0 से 10 के पैमाने पर कितने भ्रमित हो जाते हैं।

जैसा कि आपने कहा था कि फीडबैक पर मेटा चर्चा कहीं और करना बेहतर है

उदाहरण के लिए, मैंने पहले ही इस तरह की चर्चा शुरू कर दी है और कुछ वास्तविक कदम उठाए जा सकते हैं, भले ही छोटे हों: https://internals.rust-lang.org/t/idea-mandate-n-inनिर्भर-उपयोग -पहले-स्थिरीकरण-ए-फीचर/7522/14। मेरे पास RFC लिखने का समय नहीं था, इसलिए अगर कोई मुझे इसके लिए मारता है या मदद करना चाहता है, तो मुझे कोई आपत्ति नहीं होगी।

ज़्यादा बुरा? ऐसा कैसे?

क्योंकि, जब तक impl Trait को बहिष्कृत नहीं किया जाता है, आपके पास सभी 3 हैं, इसलिए भ्रम के अलावा याद रखने के लिए और भी बहुत कुछ है। यदि impl Trait को हटा दिया जाता, तो स्थिति अलग होती और यह दो दृष्टिकोणों के पेशेवरों और विपक्षों का भार होता।

impl Trait जैसा कि कैली-पिकिंग में पर्याप्त होगा। यदि आप इसे तर्क की स्थिति में उपयोग करने का प्रयास करते हैं, तो आप भ्रम का परिचय देते हैं। एचआरटीबी उस भ्रम को दूर करेंगे।

@vorner पहले मैंने तर्क दिया था कि हमें
एफडब्ल्यूआईडब्ल्यू, मुझे याद है, जब मैं जंग सीख रहा था (सी ++, डी, जावा आदि से आ रहा था), सार्वभौमिक रूप से मात्रात्मक प्रकार जेनेरिक (उनके वाक्यविन्यास सहित) को समझना आसान था (जेनेरिक में जीवनकाल थोड़ा कठिन था)।
मुझे लगता है कि तर्क प्रकारों के लिए impl Trait के परिणामस्वरूप लाइन के नीचे नए लोगों से बहुत भ्रम होगा और इस तरह के कई प्रश्न होंगे।
ऐसे किसी भी सबूत के अभाव में जिसके लिए परिवर्तन रस्ट को सीखना आसान बना देगा, हमें ऐसे बदलाव करने से बचना चाहिए, और इसके बजाय ऐसे बदलाव करने चाहिए जो रस्ट को अधिक सुसंगत बनाते हैं/रखते हैं क्योंकि निरंतरता इसे याद रखना कम से कम आसान बनाती है। रस्ट न्यूबीज़ को वैसे भी पुस्तक को दो बार पढ़ना होगा, इसलिए args के लिए impl Trait शुरुआत करके पुस्तक में जेनरिक को बाद में स्थगित करने की अनुमति देना वास्तव में किसी भी जटिलता को दूर नहीं करता है।

Btw @eddyb, क्यों हम एक और की आवश्यकता है existential के अलावा कीवर्ड प्रकार के लिए impl ? (काश हम दोनों के लिए some का उपयोग करते..)

एफडब्ल्यूआईडब्ल्यू, मुझे याद है, जब मैं जंग सीख रहा था (सी ++, डी, जावा आदि से आ रहा था), सार्वभौमिक रूप से मात्रात्मक प्रकार जेनेरिक (उनके वाक्यविन्यास सहित) को समझना आसान था (जेनेरिक में जीवनकाल थोड़ा कठिन था)।

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

तो, सवाल यह है कि क्या समुदाय के पास तर्कों का समर्थन करने के लिए कुछ डेटा के साथ बहस को फिर से खोलने के लिए पर्याप्त आवाज है?

@eddyb बीटीडब्ल्यू , हमें

क्यों नहीं forall … /me धीरे-धीरे छिप जाता है

@phaazon हमारे पास forall (यानी "सार्वभौमिक") है और यह for , उदाहरण के लिए HRTB ( for<'a> Trait<'a> )।

@eddyb हाँ, फिर इसे अस्तित्व के लिए भी उपयोग करें, जैसे हास्केल forall साथ करता है, उदाहरण के लिए।

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

मैं वास्तव में इसे नहीं समझता। उन्हें तर्क की स्थिति में रखने का क्या मतलब है? मैं इतना रस्ट नहीं लिखता, लेकिन मुझे वास्तव में -> impl Trait करने में सक्षम होना पसंद आया। मैं इसे तर्क स्थिति में कब उपयोग करूंगा?

मेरी समझ यह थी कि यह ज्यादातर निरंतरता के लिए था। अगर मैं fn हस्ताक्षर में तर्क स्थिति में impl Trait टाइप कर सकता हूं, तो मैं इसे कहीं और क्यों नहीं लिख सकता?

उस ने कहा, मैं व्यक्तिगत रूप से लोगों को "बस एक प्रकार के पैरामीटर का उपयोग करने" के लिए कहता हूं ...

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

साथ ही, समस्या यह भी पैदा होती है कि किसके पक्ष में/खिलाफ खड़े हों!

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

इसलिए आप इसका पता नहीं ले सकते

आप इसे हस्ताक्षर से अनुमान लगाकर कर सकते हैं।

उन्हें तर्क की स्थिति में रखने का क्या मतलब है?

कोई भी नहीं है क्योंकि यह एक विशेषता बाध्य का उपयोग करने जैसा ही है।

fn foo(x: impl Debug)

क्या ठीक वैसी ही बात है

fn foo<A>(x: A) where A: Debug
fn foo<A: Debug>(x: A)

इसके अलावा, इस पर विचार करें:

fn foo<A>(x: A) -> A where A: Debug

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

संक्षेप में, @iopq : आपको इसकी आवश्यकता नहीं होगी, और "चलो एक और वाक्यात्मक चीनी निर्माण जोड़ें, जिसकी वास्तव में किसी को आवश्यकता नहीं होगी, क्योंकि यह एक बहुत ही विशिष्ट उपयोग के साथ मुकाबला करता है - अर्थात अज्ञात प्रकार के चर" के अलावा कोई मतलब नहीं है ।

साथ ही, कुछ ऐसा जो मैं कहना भूल गया: यह देखना कठिन बनाता है कि आपका कार्य कैसे पैरामीटर/मोनोमोर्फिज्ड है।

@ वर्नर आंशिक खोजकर्ता के लिए इसके खिलाफ लिंट करना बहुत समझ में आता है। मैं वास्तव में हालांकि शुरू करने के लिए तर्क स्थिति में सुविधा के लिए नहीं हूं।

यह कैसे संगत है जब -> impl Trait कैली प्रकार चुनता है, जबकि x: impl Trait में कॉलर प्रकार चुनता है?

मैं समझता हूं कि इसके काम करने का कोई दूसरा तरीका नहीं है, लेकिन यह "सुसंगत" नहीं लगता है, यह संगत के विपरीत लगता है

मैं वास्तव में सहमत हूं कि यह सब कुछ है लेकिन सुसंगत है और लोग भ्रमित होंगे, नवागंतुक के साथ-साथ उन्नत कुशल जंगली।

हमारे पास दो आरएफसी थे, जिन्हें इस धागे पर संबंधित प्रश्नों को हल करने के लिए 2 साल से अधिक समय पहले उनके बीच कुल लगभग 600 टिप्पणियां मिलीं:

• रस्ट-लैंग/आरएफसीएस#1522 ("न्यूनतम impl Trait ")
• rust-lang/rfcs#1951 (" impl Trait लिए सिंटैक्स और पैरामीटर स्कोपिंग को अंतिम रूप दें, इसे तर्कों तक विस्तारित करते हुए")

(यदि आप इन चर्चाओं को पढ़ते हैं, तो आप देखेंगे कि मैं शुरू में दो खोजशब्दों के दृष्टिकोण का एक प्रबल समर्थक था। अब मुझे लगता है कि एकल खोजशब्द का उपयोग करना सही दृष्टिकोण है।)

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

इसे कैसे स्थिर किया गया है जब impl Trait को लक्षणों में fns के लिए तर्क स्थिति में समर्थन भी नहीं मिला है ??

@alexreg यह समर्थित है ...? https://play.rust-lang.org/?gist=47b1c3a3bf61f33d4acb3634e5a68388&version=stable

@daboross फिर मूल पोस्ट में चेकबॉक्स पर टिक करने की आवश्यकता है!

(बस पता चलता है कि https://play.rust-lang.org/?gist=47b1c3a3bf61f33d4acb3634e5a68388&version=stable वर्तमान में काम करता है)

मुझे लगता है कि यह अजीब है कि https://play.rust-lang.org/?gist=c29e80715ac161c6dc95f96a7f91aa8c&version=stable&mode=debug काम नहीं करता (अभी तक), इस त्रुटि संदेश के साथ और क्या है। क्या ऐसा सोचने वाला मैं अकेला हूँ? हो सकता है कि इसे लक्षणों में वापसी की स्थिति में impl Trait लिए एक चेकबॉक्स जोड़ने की आवश्यकता हो, या यह केवल impl Trait को विशेषता कार्यों के लिए तर्क-स्थिति में अनुमति देने का एक सचेत निर्णय था, existential type का उपयोग करने के लिए मजबूर करना

@ एक्लोग

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

हां--वापसी की स्थिति impl Trait लक्षणों में तब तक बंद कर दी गई जब तक हमारे पास लक्षणों में अस्तित्व के प्रकारों का उपयोग करने का अधिक व्यावहारिक अनुभव नहीं है।

@cramertj क्या हम अभी उस बिंदु पर हैं जहां हमारे पास इसे लागू करने के लिए पर्याप्त व्यावहारिक अनुभव है?

इससे पहले कि हम और सुविधाएँ जोड़ें, मैं कुछ स्थिर रिलीज़ में impl Trait देखना चाहता हूँ।

@ मार्क-आईएम मैं यह देखने में विफल हूं कि व्यक्तिगत रूप से वापसी-स्थिति impl Trait के बारे में क्या विवादास्पद है, व्यक्तिगत रूप से ... शायद मुझे कुछ याद आ रहा है।

मुझे नहीं लगता कि यह विवादास्पद है। मुझे ऐसा लग रहा है कि हम बहुत तेज़ी से सुविधाओं को जोड़ रहे हैं। यह अच्छा होगा कि कुछ समय के लिए तकनीकी ऋण पर ध्यान केंद्रित करें और पहले सेट की गई वर्तमान सुविधा के साथ अनुभव प्राप्त करें।

समझा। मुझे लगता है कि मैं इसे एक नई सुविधा से अधिक मौजूदा सुविधा का एक लापता हिस्सा मानता हूं।

मुझे लगता है कि @alexreg सही है, लक्षणों के तरीकों पर अस्तित्वगत impl Trait का उपयोग करना बहुत लुभावना है। यह वास्तव में एक नई सुविधा नहीं है, लेकिन मुझे लगता है कि इसे लागू करने की कोशिश करने से पहले कुछ चीजों को संबोधित करना है?

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

मुझे आश्चर्य है कि क्या हम लक्षणों में सार्वभौमिक निहितार्थ विशेषता पर वापस पकड़ सकते हैं ...

लेकिन हाँ, मुझे लगता है कि मैं तुम्हारा बिंदु देखता हूँ।

@ मार्क-आईएम नहीं, हम नहीं कर सकते, वे पहले से ही स्थिर हैं ।

वे कार्य कर रहे हैं, लेकिन विशेषता घोषणाओं के बारे में क्या?

@ मार्क-आईएम जैसा कि स्निपेट से पता चलता है, वे इम्प्लांट्स और ट्रेट डिक्लेरेशन दोनों में स्थिर हैं।

हम abstract type साथ कहां बस रहे हैं, इसे पकड़ने के लिए बस कूदें। व्यक्तिगत रूप से, मैं @Centril के हाल ही में प्रस्तावित सिंटैक्स और सर्वोत्तम प्रथाओं के साथ बहुत अधिक ऑन-बोर्ड

// GOOD:
type Foo: Iterator<Item: Display>;

type Bar = (impl Display, impl Debug);

// BAD
type Foo = impl Iterator<Item = impl Display>;

type Bar0: Display;
type Bar1: Debug;
type Bar = (Bar0, Bar1);

जो मेरे कुछ कोड पर लागू होता है, मुझे लगता है कि ऐसा कुछ दिखाई देगा:

// Concrete type with a generic body
struct Data<TBody> {
    ts: Timestamp,
    body: TBody,
}


// A name for an inferred iterator
type IterData = Data<impl Read>;
type Iter: Iterator<Item = IterData>;


// A function that gives us an iterator. Also takes some arbitrary range
fn iter(&self, range: impl RangeBounds<Timestamp>) -> Result<Iter, Error> { ... }


// A struct that holds on to that iterator
struct HoldsIter {
    iter: Iter,
}

मेरे लिए इसका कोई मतलब नहीं है कि type Bar = (impl Display,); अच्छा होगा, लेकिन type Bar = impl Display; बुरा होगा।

यदि हम अलग-अलग वैकल्पिक अस्तित्वगत प्रकार के सिंटैक्स पर निर्णय ले रहे हैं (सभी आरएफसी 2071 से अलग हैं?), तो क्या https://users.rust-lang.org/ पर फोरम थ्रेड ऐसा करने के लिए एक अच्छी जगह होगी?

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

type Foo = impl Trait क्या गलत है?

@daboross शायद इसके बजाय आंतरिक मंच। मैं सिंटैक्स को अंतिम रूप देने के लिए इसके बारे में एक आरएफसी लिखने पर विचार कर रहा हूं।

@daboross पहले से ही इस धागे पर वाक्य रचना पर पर्याप्त से अधिक चर्चा हो चुकी है। मुझे लगता है कि अगर @Centril इस समय इसके लिए एक RFC लिख सकता है, तो बढ़िया।

क्या लक्षणों में अस्तित्व के बारे में चर्चा के लिए मैं किसी भी मुद्दे की सदस्यता ले सकता हूं?

क्या एक वाक्य रचना या दूसरे के लिए कोई मैक्रो-संबंधित तर्क है?

@tomaka पहले मामले में type Foo = (impl Display,) वास्तव में आपके पास एकमात्र वाक्यविन्यास है। type Foo: Trait से अधिक type Foo = impl Trait लिए मेरी प्राथमिकता सिर्फ इस तथ्य से आती है कि हम एक प्रकार को बाध्य कर रहे हैं जिसे हम नाम दे सकते हैं, जैसे <TFoo: Trait> या where TFoo: Trait , जबकि impl Trait हम प्रकार का नाम नहीं दे सकते।

स्पष्ट करने के लिए, मैं यह नहीं कह रहा हूं कि type Foo = impl Bar खराब है, मैं कह रहा हूं कि type Foo: Bar साधारण मामलों में बेहतर है, आंशिक रूप से @CodrAus की प्रेरणा के कारण।

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

type Foo: Bar भी काफी साफ-सुथरा है क्योंकि अगर वह सिंटैक्स है जो किसी विशेषता में एक संबद्ध प्रकार पर बाध्य के रूप में उपयोग किया जाता है, तो आप बस विशेषता में घोषणा को इम्प्लांट में कॉपी कर सकते हैं और यह बस काम करेगा (यदि वह है वह सारी जानकारी जिसे आप उजागर करना चाहते हैं..)

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

@KodrAus

यहां बताया गया है कि मैं उन प्रकार की परिभाषाओं को कैसे पढ़ता हूं:

• type Foo: Trait अर्थ है " Foo Trait लागू करने वाला एक प्रकार है "
• type Foo = impl Trait अर्थ है " Foo किसी प्रकार का उपनाम है जो Trait "

मेरे लिए, Foo: Trait बस Foo लागू करने पर एक बाधा की घोषणा करता है Trait । एक तरह से type Foo: Trait अधूरा लगता है। ऐसा लगता है कि हमारे पास एक बाधा है, लेकिन Foo की वास्तविक परिभाषा गायब है।

दूसरी ओर, impl Trait अर्थ है "यह एक एकल प्रकार है, लेकिन संकलक इसके नाम का पता लगाता है"। इसलिए, type Foo = impl Trait अर्थ है कि हमारे पास पहले से ही एक ठोस प्रकार है (जो Trait ), जिसमें से Foo सिर्फ एक उपनाम है।

मेरा मानना ​​है कि type Foo = impl Trait सही अर्थ को अधिक स्पष्ट रूप से बताता है: Foo Trait लागू करने वाले किसी प्रकार का उपनाम है।

@stjepang

type Foo: Trait अर्थ है "फू एक प्रकार का कार्यान्वयन विशेषता है"
[..]
एक तरह से type Foo: Trait अधूरा लगता है।

इस तरह मैंने इसे भी पढ़ा (मॉड्यूलो वाक्यांश ...), और यह एक विस्तृत रूप से सही व्याख्या है। यह इस बारे में सब कुछ कहता है कि आप Foo साथ क्या कर सकते हैं (इस प्रकार के morphisms)। इसलिए, यह विस्तारित रूप से पूर्ण है। पाठकों और विशेष रूप से शुरुआती दृष्टिकोण से, मुझे लगता है कि विस्तार अधिक महत्वपूर्ण है।

दूसरी ओर, impl Trait "यह एक एकल प्रकार है, लेकिन संकलक अंतर को भरता है" का विचारोत्तेजक है। इसलिए, type Foo = impl Trait तात्पर्य है कि हमारे पास पहले से ही एक ठोस प्रकार है (जो Trait ), जिसमें से Foo एक उपनाम है, लेकिन संकलक यह पता लगाएगा कि यह वास्तव में किस प्रकार का है।

यह प्रतिनिधित्व से संबंधित एक अधिक विस्तृत और गहन व्याख्या है जो एक विस्तारित दृष्टिकोण से बेमानी है। लेकिन यह एक गहन अर्थ में अधिक पूर्ण है।

@सेंट्रिल

पाठकों और विशेष रूप से शुरुआती दृष्टिकोण से, मुझे लगता है कि विस्तार अधिक महत्वपूर्ण है।

यह प्रतिनिधित्व से संबंधित एक अधिक विस्तृत और गहन व्याख्या है जो एक विस्तारित दृष्टिकोण से बेमानी है

विस्तारित बनाम गहन द्विभाजन दिलचस्प है - मैंने पहले कभी इस तरह से impl Trait बारे में नहीं सोचा था।

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

बस मेरा 2c, हालाँकि। दूसरों के पास impl Trait अलग-अलग मानसिक मॉडल हो सकते हैं।

मैं इस टिप्पणी से पूरी तरह सहमत हूं: type Foo: Trait अधूरा लगता है। और type Foo = impl Trait impl Trait कहीं और

@joshtriplett निरंतरता चर्चा की शुरुआत के लिए https://github.com/rust-lang/rust/issues/34511#issuecomment -387238653 देखें; मेरा मानना ​​​​है कि फॉर्म फॉर्म को अनुमति देना वास्तव में लगातार काम करना है। और केवल रूपों में से एक को अनुमति देना (जो भी हो...) असंगत है। type Foo: Trait अनुमति देना https://github.com/rust-lang/rfcs/pull/2289 के साथ विशेष रूप से अच्छी तरह से फिट बैठता है जिसके साथ आप कह सकते हैं: type Foo: Iterator<Item: Display>; जो चीजों को बड़े करीने से एक समान बनाता है।

@stjepang type Foo: Bar; विस्तारित परिप्रेक्ष्य के लिए आपको टाइप थ्योरी में अस्तित्वगत परिमाणीकरण को समझने की आवश्यकता नहीं है। आपको वास्तव में यह समझने की आवश्यकता है कि Foo आपको Bar द्वारा वहन किए जाने वाले सभी कार्यों को करने की अनुमति देता है, बस। उपयोगकर्ता के दृष्टिकोण से Foo के दृष्टिकोण से, यह भी दिलचस्प है।

@सेंट्रिल

मेरा मानना ​​​​है कि अब मैं समझ गया हूं कि आप कहां से आ रहे हैं और Type: Trait सिंटैक्स को अधिक से अधिक स्थानों पर धकेलने की अपील।

टाइप-इम्प्लीमेंट्स-ट्रेट बाउंड्स के लिए उपयोग किए जा रहे : आसपास एक मजबूत अर्थ है और = का उपयोग टाइप डेफिनिशन और टाइप-बराबर-अन्य-टाइप बाउंड्स के लिए किया जा रहा है।

मुझे लगता है कि यह आपके RFC में भी स्पष्ट है। उदाहरण के लिए, इन दो प्रकार की सीमाएँ लें:

• Foo: Iterator<Item: Bar>
• Foo: Iterator<Item = impl Bar>

अंत में इन दो सीमाओं का एक ही प्रभाव होता है, लेकिन (मुझे लगता है) सूक्ष्म रूप से भिन्न हैं। पूर्व कहता है " Item को विशेषता Bar " को लागू करना चाहिए, जबकि बाद वाला कहता है " Item Bar लागू करने वाले किसी प्रकार के बराबर होना चाहिए।

मुझे एक अन्य उदाहरण का उपयोग करके इस विचार को स्पष्ट करने का प्रयास करें:

trait Person {
    type Name: Into<String>; // Just a type bound, not a definition!
    // ...
}

struct Alice;

impl Person for Alice {
    type Name = impl Into<String>; // A concrete type definition.
    // ...
}

हमें एक अस्तित्वगत प्रकार को कैसे परिभाषित करना चाहिए जो Person को लागू करता है?

• type Someone: Person , जो एक प्रकार की बाध्यता जैसा दिखता है।
• type Someone = impl Person , जो एक प्रकार की परिभाषा की तरह दिखता है।

@stjepang टाइप बाउंड की तरह Person for Alice तरह लागू कर सकते हैं:

struct Alice;
trait Person          { type Name: Into<String>; ... }
impl Person for Alice { type Name: Into<String>; ... }

देखो माँ! विशेषता और निहितार्थ दोनों के लिए { .. } अंदर का सामान समान है, इसका मतलब है कि जहां तक Name का संबंध है, आप अछूते विशेषता से पाठ को कॉपी कर सकते हैं।

एक संबद्ध प्रकार के रूप में एक प्रकार का स्तर फ़ंक्शन है (जहां पहला तर्क Self ), हम एक प्रकार के उपनाम को 0-arity संबद्ध प्रकार के रूप में देख सकते हैं, इसलिए कुछ भी अजीब नहीं हो रहा है।

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

हां; मुझे पहला वाक्यांश बिंदु पर और स्वाभाविक लगता है। :)

@ सेंट्रल हेह। क्या इसका मतलब है कि type Thing; अकेले एक अमूर्त प्रकार को पेश करने के लिए पर्याप्त है?

trait Neg           { type Output; fn neg(self) -> Self::Output; }
impl Neg for MyType { type Output; fn neg(self) -> Self::Output { self } }

@kennytm मुझे लगता है कि यह तकनीकी रूप से संभव है; लेकिन आप पूछ सकते हैं कि क्या यह वांछनीय है या नहीं, यह निहित/स्पष्ट पर अपने विचारों पर निर्भर करता है। उस विशेष मामले में मुझे लगता है कि यह लिखने के लिए तकनीकी रूप से पर्याप्त होगा:

trait Neg           { type Output; fn neg(self) -> Self::Output; }
impl Neg for MyType { fn neg(self) -> Self::Output { self } }

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

मुझे लगता है कि यह सब पढ़ने के बाद, मैं @Centril से अधिक सहमत हूं। जब मैं type Foo = impl Bar देखता हूं तो मुझे लगता है कि Foo एक विशेष प्रकार है, जैसे अन्य उपनामों के साथ। लेकिन यह नहीं है। इस उदाहरण पर विचार करें:

type Displayable = impl Display;

fn foo() -> Displayable { "hi" }
fn bar() -> Displayable { 42 }

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

कुछ लोगों ने उल्लेख किया कि type Foo: Bar "अपूर्ण" लगता है। मेरे लिए यह अच्छी बात है। कुछ अर्थों में Foo अधूरा है; हम नहीं जानते कि यह क्या है, लेकिन हम जानते हैं कि यह Bar संतुष्ट करता है।

@ मार्क-इम

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

वाह, क्या यह वाकई सच है? यह निश्चित रूप से मेरे लिए बहुत भ्रमित करने वाला होगा।

क्या कोई कारण है कि Displayable एक ठोस प्रकार के बजाय impl Display लिए एक शॉर्टहैंड होगा? क्या इस तरह का व्यवहार भी उपयोगी है, यह देखते हुए कि विशेषता उपनाम (ट्रैकिंग समस्या: https://github.com/rust-lang/rust/issues/41517) का उपयोग इसी तरह किया जा सकता है? उदाहरण:

trait Displayable = Display;

fn foo() -> impl Displayable { "hi" }
fn bar() -> impl Displayable { 42 }

@ मार्क-इम

type Displayable = impl Display;

fn foo() -> Displayable { "hi" }
fn bar() -> Displayable { 42 }

यह एक वैध उदाहरण नहीं है। RFC 2071 में अस्तित्व के प्रकारों पर संदर्भ अनुभाग से:

existential type Foo = impl Debug;

Foo का उपयोग पूरे मॉड्यूल में कई स्थानों पर i32 रूप में किया जा सकता है। हालांकि, प्रत्येक समारोह का उपयोग करता है Foo के रूप में i32 चाहिए स्वतंत्र रूप से जगह पर बाधाओं Foo ऐसी है कि यह होना चाहिए i32

प्रत्येक अस्तित्वगत प्रकार की घोषणा को कम से कम एक फ़ंक्शन बॉडी या कॉन्स्ट/स्टेटिक इनिशियलाइज़र द्वारा विवश किया जाना चाहिए। एक निकाय या इनिशियलाइज़र को या तो पूरी तरह से विवश होना चाहिए या किसी दिए गए अस्तित्व के प्रकार पर कोई प्रतिबंध नहीं लगाना चाहिए।

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

मुझे लगता है कि आपका उदाहरण expected type `&'static str` but found type `i32` की वापसी पर bar जैसा कुछ देगा, क्योंकि foo पहले से ही Displayable से &'static str के ठोस प्रकार को सेट कर चुका होगा

संपादित करें: जब तक आप इस अंतर्ज्ञान से नहीं आ रहे हैं कि

type Displayable = impl Display;

fn foo() -> Displayable { "hi" }
fn bar() -> Displayable { 42 }

के बराबर है

fn foo() -> impl Display { "hi" }
fn bar() -> impl Display { 42 }

मेरी अपेक्षा के बजाय

existential type _0 = impl Display;
type Displayable = _0;

fn foo() -> Displayable { "hi" }
fn bar() -> Displayable { 42 }

मुझे लगता है कि उन दो व्याख्याओं में से कौन सी सही है, यह RFC पर निर्भर हो सकता है कि @Centril लिख रहा होगा।

समस्या यह है कि फू किसी विशेष प्रकार के लिए उपनाम नहीं है जो कुछ विशेषता को लागू करने के लिए होता है।

मुझे लगता है कि उन दो व्याख्याओं में से कौन सी सही है, यह RFC पर निर्भर हो सकता है कि @Centril लिख रहा होगा।

type Displayable = impl Display; मौजूद होने का कारण यह है कि यह एक विशेष प्रकार के लिए एक उपनाम है।
https://github.com/rust-lang/rfcs/issues/1738 देखें, यह वह समस्या है जिसे यह सुविधा हल करती है।

@ Nemo157 आपकी अपेक्षा सही है। :)

निम्नलिखित:

type Foo = (impl Bar, impl Bar);
type Baz = impl Bar;

के लिए विसर्जित किया जाएगा:

/* existential */ type _0: Bar;
/* existential */ type _1: Bar;
type Foo = (_0, _1);

/* existential */ type _2: Bar;
type Baz = _2;

जहां _0 , _1 और _2 सभी नाममात्र के अलग-अलग प्रकार हैं इसलिए Id<_0, _1> , Id<_0, _2> , Id<_1, _2> (और सममित उदाहरण) सभी निर्जन हैं, जहां Id को ref में परिभाषित किया

अस्वीकरण: मैंने (स्वेच्छा से) आरएफसी नहीं पढ़ा है (लेकिन पता है कि यह किस बारे में है), ताकि मैं सिंटैक्स के साथ "सहज" महसूस करने पर टिप्पणी कर सकूं।

type Foo: Trait सिंटैक्स के लिए, मैं पूरी तरह से इस तरह कुछ संभव होने की उम्मीद करता हूं:

trait Trait {
    type Foo: Display;
    type Foo: Debug;
}

उसी तरह से where Foo: Display, Foo: Debug वर्तमान में संभव है।

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

ओह, और मुझे लगता है कि रस्ट के पास जितना अधिक सिंटैक्स होगा, इसे सीखना उतना ही कठिन होगा। यहां तक ​​​​कि अगर एक सिंटैक्स "सीखने में आसान" है, तब तक जब तक दो सिंटैक्स आवश्यक होते हैं, तब तक शुरुआत करने वाले को अंततः दोनों को सीखना होगा, और यदि वे पहले से मौजूद प्रोजेक्ट के लिए आते हैं, तो बाद में जल्द से जल्द होने की संभावना है।

@ एक्लोग

type Foo: Trait सिंटैक्स के लिए, मैं पूरी तरह से इस तरह कुछ संभव होने की उम्मीद करता हूं:

हो सकता है। वे "प्रकार के उपनाम" संबद्ध प्रकारों की घोषणा करते हैं (प्रकार के उपनामों की व्याख्या 0-आरी प्रकार के स्तर के कार्यों के रूप में की जा सकती है जबकि संबंधित प्रकार 1+ -री प्रकार के स्तर के कार्य हैं)। बेशक आपके पास एक ही नाम के साथ एक से अधिक संबद्ध प्रकार नहीं हो सकते हैं, जो एक मॉड्यूल में एक ही नाम के साथ दो प्रकार के उपनामों को परिभाषित करने की कोशिश करने जैसा होगा। impl , type Foo: Bar भी अस्तित्वगत परिमाणीकरण से मेल खाता है।

ओह, और मुझे लगता है कि रस्ट के पास जितना अधिक सिंटैक्स होगा, इसे सीखना उतना ही कठिन होगा।

दोनों वाक्यविन्यास पहले से ही उपयोग किए जा रहे हैं। type Foo: Bar; पहले से ही लक्षणों में कानूनी है, और सार्वभौमिक परिमाणीकरण के लिए भी Foo: Bar जहां Foo एक प्रकार चर है। impl Trait का उपयोग रिटर्न स्थिति में अस्तित्वगत परिमाणीकरण और तर्क स्थिति में सार्वभौमिक परिमाणीकरण के लिए किया जाता है। दोनों प्लग को भाषा में संगति अंतराल की अनुमति देना। वे विभिन्न परिदृश्यों के लिए भी इष्टतम हैं, और इसलिए दोनों आपको वैश्विक इष्टतम प्रदान करते हैं।

इसके अलावा, शुरुआत करने वाले को type Foo = (impl Bar, impl Baz); आवश्यकता होने की संभावना नहीं है। अधिकांश उपयोग संभवतः type Foo: Bar; ।

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

मैं पसंद करूंगा अगर इसे स्पष्ट किया जाए। तो इसके बजाय

type Foo = impl SomeTrait;
fn foo_func() -> Foo { ... }

हम लिखेंगे

fn foo_func() -> impl SomeTrait { ... }
type Foo = return_type_of(foo_func);

(रिटर्न_टाइप_ऑफ के नाम से बाइक शेड किया जाना है), या यहां तक ​​कि

fn foo_func() -> impl SomeTrait as Foo { ... }

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

trait Bar
{
    type Assoc: SomeTrait;
    fn func() -> Assoc;
}

impl Bar for SomeType
{
    type Assoc = return_type_of(Self::func);
    fn func() -> Assoc { ... }
}

या और भी

impl Bar for SomeType
{
    fn func() -> impl SomeTrait as Self::Assoc { ... }
}

मुझे खेद है कि अगर इस पर पहले ही चर्चा हो चुकी है और खारिज कर दिया गया है, लेकिन मैं इसे खोजने में असमर्थ था।

@सेंट्रिल

हो सकता है। वे "प्रकार के उपनाम" संबद्ध प्रकारों की घोषणा करते हैं (प्रकार के उपनामों की व्याख्या 0-आरी प्रकार के स्तर के कार्यों के रूप में की जा सकती है जबकि संबंधित प्रकार 1+ -री प्रकार के स्तर के कार्य हैं)। बेशक आपके पास एक ही नाम के साथ एक से अधिक संबद्ध प्रकार नहीं हो सकते हैं, जो एक मॉड्यूल में एक ही नाम के साथ दो प्रकार के उपनामों को परिभाषित करने की कोशिश करने जैसा होगा। एक इम्प्लांट में, टाइप करें फू: बार भी अस्तित्वगत परिमाणीकरण से मेल खाता है।

(क्षमा करें, मेरा मतलब इसे impl Trait for Struct में रखना था, न कि trait Trait )

मुझे खेद है, मुझे यकीन नहीं है कि मैं समझता हूँ। मैं जो कहने की कोशिश करता हूं, वह मेरे लिए कोड जैसा है

impl Trait for Struct {
    type Type: Debug;
    type Type: Display;

    fn foo() -> Self::Type { 42 }
}

(पूर्ण संस्करण के लिए खेल का मैदान लिंक)
ऐसा लगता है कि इसे काम करना चाहिए।

क्योंकि यह सिर्फ Type पर दो सीमाएं लगा रहा है, ठीक उसी तरह जैसे where Type: Debug, Type: Display work ।

इस अनुमति दी जा नहीं है (मैं क्या द्वारा "बेशक आप एक विशेषता में एक ही नाम के साथ कई संबद्ध प्रकार नहीं हो सकता" समझने के लिए लग रहे हैं? लेकिन लिखित रूप में मेरी त्रुटि दिया trait Trait के बजाय impl Trait for Struct मुझे यकीन नहीं है), तो मुझे लगता है कि यह type Type: Trait सिंटैक्स के साथ एक समस्या है।

फिर, trait घोषणा के अंदर, सिंटैक्स पहले से ही type Type: Trait , और कई परिभाषाओं की अनुमति नहीं देता है। तो मुझे लगता है कि शायद यह नाव बहुत पहले ही रवाना हो चुकी है…

हालाँकि, जैसा कि @stjepang और @joshtriplett द्वारा ऊपर बताया गया है, type Type: Trait अधूरा लगता है। और जबकि यह trait घोषणाओं में समझ में आता है (यह वास्तव में अपूर्ण होने के लिए डिज़ाइन किया गया है, भले ही यह अजीब है कि यह एकाधिक परिभाषाओं की अनुमति नहीं देता है), यह impl Trait ब्लॉक में समझ में नहीं आता है , जहां प्रकार निश्चित रूप से ज्ञात होना चाहिए (और वर्तमान में केवल type Type = RealType रूप में लिखा जा सकता है)

impl Trait का उपयोग रिटर्न स्थिति में अस्तित्वगत परिमाणीकरण और तर्क स्थिति में सार्वभौमिक परिमाणीकरण के लिए किया जाता है।

हां, मैंने इसे लिखते समय तर्क की स्थिति में impl Trait बारे में भी सोचा था, और मुझे आश्चर्य हुआ कि क्या मुझे कहना चाहिए कि मैं तर्क स्थिति में impl Trait लिए उसी तर्क का समर्थन करता, मुझे पता था कि यह स्थिरीकरण के दौर से गुजर रहा था . उसने कहा कि मुझे लगता है कि इस बहस को फिर से प्रज्वलित न करना बेहतर होगा :)

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

इष्टतम और सरलता

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

impl Trait और :

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

एक शुरुआत करने वाले की कल्पना करें जिसने हमेशा type Type: Trait को अपने पहले type Type = impl Trait । वे शायद अनुमान लगा सकते हैं कि क्या हो रहा है, लेकिन मुझे पूरा यकीन है कि "डब्ल्यूटीएफ क्या वह है? मैं वर्षों से रस्ट का उपयोग कर रहा हूं और अभी भी सिंटैक्स है जो मैंने कभी नहीं देखा?"। जो कमोबेश वह जाल है जिसमें C++ गिर गया।

फ़ीचर ब्लोट

मैं जो सोच रहा हूं, मूल रूप से, इसमें जितनी अधिक विशेषताएं हैं, भाषा को सीखना उतना ही कठिन है। और मुझे type Type: Trait से अधिक type Type = impl Trait का उपयोग करने का कोई बड़ा लाभ नहीं दिख रहा है: यह 6 वर्णों की तरह सहेजा गया है?

बीत रहा है rustc जब देखकर उत्पादन एक त्रुटि type Type: Trait का कहना है कि व्यक्ति इसे लिखने का उपयोग करने के type Type = impl Trait मेरे लिए और अधिक समझ बनाने हैं: कम से कम वहाँ बातें लिखने की एक भी तरीका है , यह सभी के लिए समझ में आता है ( impl Trait पहले से ही स्पष्ट रूप से वापसी की स्थिति में एक अस्तित्व के रूप में पहचाना जाता है), और इसमें सभी उपयोग के मामले शामिल हैं। और अगर लोग जो सोचते हैं उसका उपयोग करने की कोशिश करते हैं (हालांकि मैं इससे असहमत हूं, मेरे लिए = impl Trait वर्तमान = i32 की तुलना में अधिक सहज है), वे सही तरीके से पुनर्निर्देशित हो जाते हैं इसे लिखने का पारंपरिक-सही तरीका।

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

1.5 साल पहले खोले गए अंक में typeof पर संक्षेप में चर्चा की गई थी: https://github.com/rust-lang/rfcs/issues/1738#issuecomment -258353755

एक शुरुआत के रूप में बोलते हुए, मुझे type Foo: Bar सिंटैक्स भ्रमित करने वाला लगता है। यह संबंधित प्रकार का सिंटैक्स है, लेकिन उन्हें लक्षणों में माना जाता है, न कि संरचना में। यदि आप एक बार impl Trait देखते हैं, तो आप समझ सकते हैं कि वह क्या है, या अन्यथा आप इसे देख सकते हैं। अन्य वाक्यविन्यास के साथ ऐसा करना कठिन है, और मुझे यकीन नहीं है कि लाभ क्या है।

ऐसा लगता है कि भाषा टीम के कुछ लोग अस्तित्व के प्रकारों को नाम देने के लिए वास्तव में impl Trait का उपयोग करने का विरोध कर रहे हैं, इसलिए वे इसके बजाय किसी और चीज का उपयोग करेंगे। यहां की टिप्पणी भी मेरे लिए बहुत कम मायने रखती है।

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

वाह, यह बिल्कुल नहीं है जो मुझे समझ में आया। धन्यवाद @ Nemo157 मुझे सीधा करने के लिए!

उस स्थिति में, मैं वास्तव में = वाक्यविन्यास पसंद करूंगा।

@ एक्लोग

तो मुझे लगता है कि यह type Type: Trait सिंटैक्स के साथ एक समस्या है।

इसकी अनुमति दी जा सकती है और इसे पूरी तरह से परिभाषित किया जाएगा, लेकिन आप आमतौर पर where Type: Foo + Bar बजाय where Type: Foo, Type: Bar लिखते हैं, ताकि यह बहुत अच्छा विचार न लगे। आप इस मामले के लिए एक अच्छा त्रुटि संदेश भी आसानी से सक्रिय कर सकते हैं, यह सुझाव देते हुए कि आप संबंधित प्रकार के मामले में इसके बजाय Foo + Bar लिखते हैं।

type Foo = impl Bar; भी समझने योग्य समस्याएं हैं जिसमें आप = impl Bar और निष्कर्ष निकालते हैं कि आप इसे प्रत्येक घटना पर प्रतिस्थापित कर सकते हैं जहां इसे -> impl Bar रूप में उपयोग किया जाता है; लेकिन यह काम नहीं करेगा। @ मार्क-आईएम ने यह व्याख्या की है, जो कि एक और अधिक संभावित गलती की तरह लगता है। इसलिए, मैं यह निष्कर्ष निकालता हूं कि सीखने की क्षमता के लिए type Foo: Bar; बेहतर विकल्प है।

हालाँकि, जैसा कि @stjepang और @joshtriplett द्वारा ऊपर बताया गया है, टाइप करें: विशेषता अधूरा लगता है।

यह एक विस्तारित पीओवी से अधूरा नहीं है। आपको type Foo: Bar; से ठीक उतनी ही जानकारी मिलती है जितनी आपको type Foo = impl Bar; से मिलती है। तो आप type Foo: Bar; साथ क्या कर सकते हैं , इस परिप्रेक्ष्य से, यह पूरा हो गया है। वास्तव में, बाद वाले को type _0: Bar; type Foo = _0; रूप में उतारा जाता है।

संपादित करें: मेरा मतलब यह था कि कुछ के लिए यह अधूरा लग सकता है, यह तकनीकी दृष्टिकोण से नहीं है।

उसने कहा कि मुझे लगता है कि इस बहस को फिर से प्रज्वलित न करना बेहतर होगा :)

वह एक अच्छा विचार है। हमें भाषा पर विचार करना चाहिए क्योंकि यह डिजाइन करते समय है, न कि जैसा हम चाहते थे।

खैर, मुझे लगता है कि कभी-कभी सादगी के पक्ष में इष्टतम खोना अच्छी बात है।

अगर हमें सादगी के लिए जाना चाहिए, तो मैं इसके बजाय type Foo = impl Bar; दूंगा।
यह ध्यान दिया जाना चाहिए कि सी की सादगी (माना जाता है, क्योंकि हास्केल कोर और इसी तरह की चीजें शायद ध्वनि के दौरान सरल होती हैं ..) अभिव्यक्ति और सुदृढ़ता की बात करते समय एक तेज कीमत पर आती है। भाषा डिजाइन में सी मेरा उत्तर सितारा नहीं है; से बहुत दूर।

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

लेकिन वे अपने शब्दार्थ में भिन्न नहीं होंगे। एक दूसरे के लिए desugars।
मुझे लगता है कि type Foo: Bar; या type Foo = impl Bar लिखने की कोशिश करने का भ्रम केवल उनमें से एक के लिए काम नहीं करना है, भले ही दोनों के पास पूरी तरह से परिभाषित अर्थशास्त्र है, केवल उपयोगकर्ता के रास्ते में है। यदि कोई उपयोगकर्ता type Foo = impl Bar; लिखने का प्रयास करता है, तो एक लिंट आग लगती है और type Foo: Bar; का प्रस्ताव करती है। एक प्रकार का वृक्ष उपयोगकर्ता को अन्य वाक्य रचना के बारे में सिखा रहा है।
मेरे लिए, यह महत्वपूर्ण है कि भाषा एक समान और सुसंगत हो; यदि हमने कहीं दोनों सिंटैक्स का उपयोग करने का निर्णय लिया है, तो हमें उस निर्णय को लगातार लागू करना चाहिए।

एक शुरुआत करने वाले की कल्पना करें जिसने हमेशा type Type: Trait को अपने पहले type Type = impl Trait ।

इस विशिष्ट मामले में, एक लिंट आग लग जाएगा, और पूर्व सिंटैक्स की सिफारिश करेगा। जब type Foo = (impl Bar, impl Baz); बात आती है, तो शुरुआत करने वाले को किसी भी मामले में -> impl Trait सीखना होगा, ताकि वे इसका अर्थ निकालने में सक्षम हों।

जो कमोबेश वह जाल है जिसमें C++ गिर गया।

सी ++ की समस्या मुख्य रूप से यह है कि यह काफी पुरानी है, इसमें सी का सामान है, और बहुत सारी सुविधाएं बहुत सारे प्रतिमानों का समर्थन करती हैं। ये अलग-अलग विशेषताएं नहीं हैं, बस अलग-अलग सिंटैक्स हैं।

मैं जो सोच रहा हूं, मूल रूप से, इसमें जितनी अधिक विशेषताएं हैं, भाषा को सीखना उतना ही कठिन है।

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

और मुझे type Type: Trait से अधिक type Type = impl Trait: का उपयोग करने का कोई बड़ा लाभ नहीं दिख रहा है, जैसे, 6 वर्ण सहेजे गए हैं?

हाँ, केवल 6 वर्ण सहेजे गए हैं। लेकिन अगर हम type Foo: Iterator<Item: Iterator<Item: Display>>; , तो हम इसके बजाय प्राप्त करेंगे: type Foo = impl Iterator<Item = impl Iterator<Item = impl Display>>; जिसमें बहुत अधिक शोर है। type Foo: Bar; भी बाद की तुलना में अधिक प्रत्यक्ष है, गलत व्याख्या (पुनः प्रतिस्थापन ..) के लिए कम प्रवण है, और संबंधित प्रकारों के लिए बेहतर काम करता है (प्रकार को विशेषता से कॉपी करें ..)।
इसके अलावा, type Foo: Bar को स्वाभाविक रूप से type Foo: Bar = ConcreteType; तक बढ़ाया जा सकता है जो ठोस प्रकार को उजागर करेगा लेकिन यह भी सुनिश्चित करेगा कि यह Bar संतुष्ट करता है। type Foo = impl Trait; लिए ऐसा कुछ नहीं किया जा सकता है।

type Type: Trait देखते समय rustc आउटपुट में त्रुटि होने पर जो कहता है कि इसे लिखने वाला व्यक्ति type Type = impl Trait का उपयोग करने के लिए मुझे और अधिक समझ में आता है: कम से कम चीजों को लिखने का एक ही तरीका है,

वे इसे लिखने के पारंपरिक-सही तरीके से सही तरीके से पुनर्निर्देशित हो जाते हैं।

मैं प्रस्ताव कर रहा हूं कि चीजों को लिखने का एक पारंपरिक तरीका हो; type Foo: Bar; ।

@lnicola

एक शुरुआत के रूप में बोलते हुए, मुझे type Foo: Bar सिंटैक्स भ्रमित करने वाला लगता है। यह संबंधित प्रकार का सिंटैक्स है, लेकिन उन्हें लक्षणों में माना जाता है, न कि संरचना में।

मैं दोहराता हूँ कि प्रकार के उपनामों को वास्तव में संबद्ध प्रकारों के रूप में देखा जा सकता है। आप कह सकेंगे:

trait Foo        { type Baz: Quux; }
// User of `Bar::Baz` can conclude `Quux` but nothing more!
impl Foo for Bar { type Baz: Quux; }

// User of `Wibble` can conclude `Quux` but nothing more!
type Wibble: Quux;

हम देखते हैं कि यह संबद्ध प्रकारों और प्रकार के उपनामों में ठीक उसी तरह काम करता है।

हाँ, केवल 6 वर्ण सहेजे गए हैं। लेकिन अगर हम type Foo: Iterator<Item: Iterator<Item: Display>>; , तो हम इसके बजाय प्राप्त करेंगे: type Foo = impl Iterator<Item = impl Iterator<Item = impl Display>> ; जिसमें बहुत अधिक शोर होता है।

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

type Foo: Iterator<Item: Iterator<Item: Display>>;
type Foo = impl Iterator<Item: Iterator<Item: Display>>;
existential type Foo: Iterator<Item: Iterator<Item: Display>>;
existential type Foo = impl Iterator<Item: Iterator<Item: Display>>;

अपने प्रस्तावित शॉर्टहैंड Trait<AssociatedType: Bound> बजाय Trait<AssociatedType = impl Bound> सिंटैक्स का उपयोग करने में सक्षम होने के कारण संबंधित प्रकार के अस्तित्व के प्रकार (या तो नामित या अज्ञात) के लिए अज्ञात अस्तित्व प्रकार घोषित करने के लिए एक स्वतंत्र विशेषता है (लेकिन शायद इसमें प्रासंगिक है) अस्तित्वगत प्रकार की विशेषताओं के पूरे सेट को सुसंगत रखने की शर्तें)।

@ Nemo157 वे अलग-अलग विशेषताएं हैं, हाँ; लेकिन मुझे लगता है कि निरंतरता के लिए उन पर एक साथ विचार करना स्वाभाविक है।

@सेंट्रिल

मुझे खेद है, लेकिन वे गलत हैं। यह एक विस्तारित पीओवी से अधूरा नहीं है।

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

यह भी देखें कि इस धागे में, लोगों ने इस सटीक वाक्यविन्यास अंतर के साथ एक व्याख्या समस्या का प्रदर्शन किया। type Foo = impl Trait ऐसा लगता है कि यह स्पष्ट करता है कि Foo एक विशिष्ट लेकिन अनाम ठोस प्रकार है चाहे आप इसे कितनी बार उपयोग करें, बजाय एक विशेषता के उपनाम के जो एक अलग ठोस प्रकार पर ले सकता है हर बार जब आप इसका इस्तेमाल करते हैं।

मुझे लगता है कि यह लोगों को यह बताने में मदद करता है कि वे -> impl Trait बारे में वे सभी चीजें ले सकते हैं जो वे जानते हैं और उन्हें type Foo = impl Trait लागू कर सकते हैं; एक सामान्यीकृत अवधारणा है impl Trait जिसे वे दोनों जगहों पर बिल्डिंग ब्लॉक के रूप में उपयोग करते हुए देख सकते हैं। type Foo: Trait जैसा सिंटैक्स उस सामान्यीकृत बिल्डिंग ब्लॉक को छुपाता है।

@joshtriplett

मैं सुझाव दे रहा था कि यह अधूरा लगता है; यह मुझे और दूसरों को गलत लगता है।

ठीक है; मेरा प्रस्ताव है कि हम यहां incomplete से भिन्न शब्द का उपयोग करें क्योंकि मेरे लिए, यह जानकारी की कमी का सुझाव देता है।

यह भी देखें कि इस धागे में, लोगों ने इस सटीक वाक्यविन्यास अंतर के साथ एक व्याख्या समस्या का प्रदर्शन किया।

मैंने जो देखा वह एक व्याख्या की गलती थी, जो धागे में की गई थी, इस बारे में कि type Foo = impl Bar; अर्थ है। एक व्यक्ति ने Foo विभिन्न उपयोगों को नाममात्र के एक ही प्रकार के नहीं, बल्कि विभिन्न प्रकारों के रूप में व्याख्यायित किया। वह है, बिल्कुल: "एक विशेषता के लिए एक उपनाम जो हर बार आपके द्वारा उपयोग किए जाने पर एक अलग ठोस प्रकार ले सकता है" ।

कुछ ने कहा है कि type Foo: Bar; भ्रमित करने वाला है, लेकिन मुझे यकीन नहीं है कि type Foo: Bar; की वैकल्पिक व्याख्या क्या है जो इच्छित अर्थ से अलग है। मुझे वैकल्पिक व्याख्याओं के बारे में सुनने में दिलचस्पी होगी।

@सेंट्रिल

मैं दोहराता हूँ कि प्रकार के उपनामों को वास्तव में संबद्ध प्रकारों के रूप में देखा जा सकता है।

वे कर सकते हैं, लेकिन अभी संबंधित प्रकार लक्षणों से संबंधित हैं। impl Trait हर जगह, या लगभग काम करता है। यदि आप impl Trait को एक संबद्ध प्रकार के रूप में प्रस्तुत करना चाहते हैं, तो आपको एक साथ दो अवधारणाएँ प्रस्तुत करनी होंगी। यानी, आप impl Trait को फ़ंक्शन रिटर्न प्रकार के रूप में देखते हैं, अनुमान लगाते हैं या पढ़ते हैं कि यह किस बारे में है, फिर जब आप एक प्रकार के उपनाम में impl Trait देखते हैं, तो आप उस ज्ञान का पुन: उपयोग कर सकते हैं।

इसकी तुलना एक विशेषता परिभाषा में संबद्ध प्रकारों को देखने से करें। उस स्थिति में आपको लगता है कि यह कुछ ऐसा है जिसे अन्य structs को परिभाषित या कार्यान्वित करना होगा। लेकिन अगर आप किसी विशेषता के बाहर type Foo: Debug पाते हैं, तो आप नहीं जान पाएंगे कि वह क्या है। इसे लागू करने वाला कोई नहीं है, तो क्या यह किसी प्रकार की आगे की घोषणा है? क्या इसका विरासत से कोई लेना-देना है, जैसा कि C++ में होता है? क्या यह एक एमएल मॉड्यूल की तरह है जहां कोई और प्रकार चुनता है? और अगर आपने पहले impl Trait देखा है, तो उनके बीच लिंक बनाने के लिए कुछ भी नहीं है। हम fn foo() -> impl ToString लिखते हैं, न कि fn foo(): ToString ।

टाइप फू = इम्प्ला बार; इसमें समझने योग्य समस्याएं भी हैं जिनमें आप = इम्प्ला बार देखते हैं और निष्कर्ष निकालते हैं कि आप इसे प्रत्येक घटना पर प्रतिस्थापित कर सकते हैं जहां इसका उपयोग -> इम्प्ला बार के रूप में किया जाता है

मैं इसे यहाँ कहा है से पहले, लेकिन सोच की तरह का है कि let x = foo(); साधन का उपयोग कर सकते x के बजाय foo() । किसी भी मामले में, यह एक विवरण है कि जरूरत पड़ने पर कोई व्यक्ति जल्दी से देख सकता है, लेकिन मूल रूप से अवधारणा को नहीं बदलता है।

यानी, यह पता लगाना आसान है कि यह किस बारे में है (एक घटा हुआ प्रकार जैसे -> impl Trait ), भले ही आप नहीं जानते कि यह वास्तव में कैसे काम करता है (क्या होता है जब आपके पास इसके लिए परस्पर विरोधी परिभाषाएं होती हैं)। अन्य वाक्यविन्यास के साथ यह समझना भी मुश्किल है कि यह क्या है।

@सेंट्रिल

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

"अपूर्ण" का मतलब जानकारी की कमी नहीं है, इसका मतलब यह हो सकता है कि कुछ ऐसा लगता है कि इसमें कुछ और होना चाहिए और नहीं।

type Foo: Trait; एक पूर्ण घोषणा की तरह नहीं दिखता है। ऐसा लगता है कि इसमें कुछ कमी है। और यह type Foo = SomeType<X, Y, Z>; से अनावश्यक रूप से अलग लगता है।

शायद हम इस बिंदु पर पहुंच रहे हैं कि हमारे वन-लाइनर्स वास्तव में type Inferred: Trait और type Inferred = impl Trait बीच इस आम सहमति के अंतर को पाट नहीं सकते हैं।

क्या आपको लगता है कि किसी भी सिंटैक्स (यहां तक ​​​​कि आरएफसी में निर्दिष्ट एक) के साथ इस सुविधा के प्रयोगात्मक कार्यान्वयन को एक साथ रखना उचित होगा ताकि हम बड़े कार्यक्रमों में इसके साथ खेलना शुरू कर सकें कि यह संदर्भ में कैसे फिट बैठता है?

@lnicola

[..] impl Trait हर जगह काम करता है, या लगभग

खैर, Foo: Bound भी लगभग हर जगह काम करता है;)

लेकिन अगर आप किसी विशेषता के बाहर type Foo: Debug पाते हैं, तो आप नहीं जान पाएंगे कि वह क्या है।

मुझे लगता है कि इसका उपयोग करने की प्रगति: विशेषता -> impl -> सीखने में उपनाम एड्स टाइप करें।
इसके अलावा, मुझे लगता है कि अनुमान है कि "फू प्रकार डिबग लागू करता है" की संभावना है
type Foo: Debug लक्षणों में और सामान्य सीमा से देखना और यह भी सही है।

क्या इसका विरासत से कोई लेना-देना है, जैसा कि C++ में होता है?

मुझे लगता है कि रस्ट में इनहेरिटेंस की कमी को हम जिस फीचर के बारे में चर्चा कर रहे हैं उसे सीखने की तुलना में बहुत पहले के चरण में सीखने की जरूरत है क्योंकि यह रस्ट के लिए इतना मौलिक है।

क्या यह एक एमएल मॉड्यूल की तरह है जहां कोई और प्रकार चुनता है?

यह अनुमान type Foo = impl Bar; के लिए भी बनाया जा सकता है क्योंकि arg: impl Bar जहां कॉलर (उपयोगकर्ता) प्रकार चुनता है। मेरे लिए, उपयोगकर्ता जिस प्रकार का चयन करता है, उसके लिए type Foo: Bar; संभावना कम लगती है।

मैं इसे यहाँ कहा है से पहले, लेकिन सोच की तरह का है कि let x = foo(); साधन का उपयोग कर सकते x के बजाय foo() ।

यदि भाषा संदर्भात्मक रूप से पारदर्शी है, तो आप x को foo() प्रतिस्थापित कर सकते हैं । जब तक हम सिस्टम में type Foo = impl Foo; जोड़ते हैं, तब तक उपनामों को संदर्भित रूप से पारदर्शी टाइप किया जाता है। इसके विपरीत, ऐसे में पहले से ही है कि अगर एक बाध्यकारी x = foo() उपलब्ध है, तो अन्य foo() में साथ बदली हैं x ।

@joshtriplett

"अपूर्ण" का मतलब जानकारी की कमी नहीं है, इसका मतलब यह हो सकता है कि कुछ ऐसा लगता है कि इसमें कुछ और होना चाहिए और नहीं।

काफी उचित; लेकिन क्या होना चाहिए था कि यह नहीं है?

type Foo: Trait; एक पूर्ण घोषणा की तरह नहीं दिखता है।

मुझे पूरा लगता है। यह एक निर्णय की तरह दिखता है कि Foo Trait संतुष्ट करता है जो कि सटीक अर्थ है।

@ मेरे लिए "कुछ गायब" वास्तविक प्रकार है जिसके लिए यह उपनाम है। यह मेरे पहले के भ्रम से थोड़ा संबंधित है। ऐसा नहीं है कि ऐसा कोई प्रकार नहीं है, बस वह प्रकार गुमनाम है... = सूक्ष्मता से उपयोग करने का अर्थ है कि एक प्रकार है और यह हमेशा एक ही प्रकार का होता है लेकिन हम इसका नाम नहीं दे सकते।

मुझे लगता है कि हम हालांकि इन तर्कों को समाप्त कर रहे हैं। प्रयोगात्मक रूप से दोनों वाक्यविन्यासों को लागू करना और यह देखना बहुत अच्छा होगा कि सबसे अच्छा क्या काम करता है।

@ मार्क-इम

@ मेरे लिए "कुछ गायब" वास्तविक प्रकार है जिसके लिए यह उपनाम है। यह मेरे पहले के भ्रम से थोड़ा संबंधित है। ऐसा नहीं है कि ऐसा कोई प्रकार नहीं है, बस वह प्रकार गुमनाम है... = सूक्ष्मता से उपयोग करने का अर्थ है कि एक प्रकार है और यह हमेशा एक ही प्रकार का होता है लेकिन हम इसका नाम नहीं दे सकते।

ठीक ऐसा ही मुझे भी लगता है।

जल्द ही दो आस्थगित मदों से निपटने का कोई मौका, साथ ही आजीवन elision के बारे में मुद्दा? मैं इसे स्वयं करूँगा, लेकिन पता नहीं कैसे!

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

@varkor क्या शब्दार्थ अस्पष्ट हैं? AFAIK impl Trait के शब्दार्थ के बारे में कुछ भी RFC 1951 के बाद से नहीं बदला है, और 2071 में विस्तारित हुआ है।

@alexreg मेरे पास कोई योजना नहीं थी, लेकिन यहां एक मोटा रूपरेखा है: पार्सिंग को जोड़ने के बाद, आपको static s और const s के प्रकारों को एक अस्तित्वगत निहितार्थ के अंदर कम करने की आवश्यकता है विशेषता संदर्भ, जैसा कि यहां रिटर्न प्रकार के कार्यों के लिए किया जाता है DefId को ImplTraitContext::Existential वैकल्पिक बनाना चाहेंगे, क्योंकि आप नहीं चाहते कि आपका impl Trait पेरेंट फ़ंक्शन परिभाषा से जेनरिक चुनें। यह आपको एक सभ्य तरीके से प्राप्त करना चाहिए। यदि आप @ oli-obk के अस्तित्वगत प्रकार PR के शीर्ष पर आधारित हैं तो आपके पास एक आसान समय हो सकता है।

@cramertj : भाषा में impl Trait का शब्दार्थ पूरी तरह से फ़ंक्शन हस्ताक्षरों में इसके उपयोग तक ही सीमित है और यह सच नहीं है कि इसे अन्य पदों पर विस्तारित करने का एक स्पष्ट अर्थ है। मैं जल्द ही इस बारे में और विस्तार से कुछ कहूंगा, जहां अधिकांश बातचीत चल रही प्रतीत होती है।

@varkor

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

अर्थ RFC 2071 में निर्दिष्ट किया गया था।

@cramertj : आरएफसी 2071 में अर्थ अस्पष्ट है और "अस्तित्ववादी प्रकार" वाक्यांश का अर्थ क्या है इसकी कई व्याख्याओं की अनुमति देता है।

टीएल; डीआर - मैंने impl Trait लिए एक सटीक अर्थ निर्धारित करने का प्रयास किया है, जो मुझे लगता है कि विवरण स्पष्ट करता है जो कम से कम सहज रूप से अस्पष्ट थे; एक नए प्रकार के उपनाम वाक्यविन्यास के प्रस्ताव के साथ।

जंग में मौजूद प्रकार (पोस्ट)

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

मैंने अपने कुछ निष्कर्षों का एक छोटा सा सारांश लिखा है। इस की एक व्याख्या प्रदान करता है impl Trait जो मुझे लगता है कि काफी साफ है, और ठीक तर्क-स्थिति के बीच मतभेद का वर्णन करता है impl Trait और बदले स्थिति impl Trait (जो "universally- नहीं है मात्राबद्ध" बनाम "अस्तित्व-मात्राबद्ध")। कुछ व्यावहारिक निष्कर्ष भी हैं।

इसमें, मैं एक "अस्तित्व प्रकार के उपनाम" की सामान्य रूप से बताई गई आवश्यकताओं को पूरा करने वाला एक नया वाक्यविन्यास प्रस्तावित करता हूं:
type Foo: Bar = _;

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

जंग में मौजूद प्रकार (पोस्ट)

@varkor

RFC 2071 अस्पष्ट है और "अस्तित्ववादी प्रकार" वाक्यांश का क्या अर्थ है, इसकी कई व्याख्याओं की अनुमति देता है।

यह कैसे अस्पष्ट है? मैंने आपकी पोस्ट पढ़ ली है-- मैं अभी भी स्थिरांक और स्थिरांक में गैर-गतिशील अस्तित्व के केवल एक अर्थ से अवगत हूं। यह उसी तरह व्यवहार करता है जैसे प्रति-आइटम एक नई अस्तित्व प्रकार परिभाषा पेश करके वापसी स्थिति impl Trait करता है।

type Foo: Bar = _;

हमने RFC 2071 के दौरान इस सिंटैक्स पर चर्चा की। जैसा कि मैंने वहां कहा, मुझे यह पसंद है कि यह स्पष्ट रूप से प्रदर्शित करता है कि Foo एक एकल अनुमानित प्रकार है और यह गैर-अनुमानित प्रकारों के लिए जगह छोड़ देता है जो वर्तमान मॉड्यूल के बाहर अस्तित्व में हैं ( उदाहरण के लिए type Foo: Bar = u32; )। मुझे इसके दो पहलू नापसंद थे: (1) इसका कोई कीवर्ड नहीं है, और इसलिए इसे खोजना कठिन है और (बी) इसमें type Foo = impl Trait तुलना में समान वर्बोसिटी समस्या है कि abstract type Foo: Bar; सिंटैक्स है: type Foo = impl Iterator<Item = impl Display>; type Foo: Iterator<Item = MyDisplay> = _; type MyDisplay: Display = _; बन जाता है। मुझे नहीं लगता कि इनमें से कोई भी डील-ब्रेकर है, लेकिन यह एक तरह से या किसी अन्य IMO की स्पष्ट जीत नहीं है।

@cramertj अस्पष्टता यहाँ सामने आती है:

type Foo = impl Bar;
fn f() -> Foo { .. }
fn g() -> Foo { .. }

यदि Foo वास्तव में एक अस्तित्वगत प्रकार के लिए एक प्रकार का उपनाम था, तो f और g विभिन्न ठोस रिटर्न प्रकारों का समर्थन करेंगे। कई लोगों ने सहज रूप से उस सिंटैक्स को इस तरह से पढ़ा है, और वास्तव में RFC 2071 सिंटैक्स चर्चा में कुछ प्रतिभागियों ने केवल यह महसूस किया है कि हालिया डिस्कॉर्ड चर्चा के हिस्से के रूप में प्रस्ताव इस तरह काम नहीं करता है ।

समस्या यह है कि, विशेष रूप से तर्क-स्थिति impl Trait के सामने, यह बिल्कुल स्पष्ट नहीं है कि अस्तित्वगत क्वांटिफायर कहां जाना है। तर्कों के लिए यह कसकर गुंजाइश है; वापसी की स्थिति के लिए यह कसकर गुंजाइश लगता है लेकिन इससे कहीं अधिक चौड़ा हो जाता है; type Foo = impl Bar दोनों स्थितियां प्रशंसनीय हैं। _ -आधारित सिंटैक्स एक व्याख्या की ओर इशारा करता है जिसमें "अस्तित्ववादी" भी शामिल नहीं है, इस समस्या को बड़े करीने से दूर करना।

यदि Foo वास्तव में एक अस्तित्वगत प्रकार के लिए एक प्रकार का उपनाम था

(जोर मेरा)। मैंने पढ़ा है कि 'ए' 'एक विशिष्ट' के रूप में जिसका अर्थ है f और g _not_ विभिन्न ठोस रिटर्न प्रकारों का समर्थन करेगा, क्योंकि वे एक ही अस्तित्व के प्रकार को संदर्भित करते हैं। मैंने हमेशा type Foo = impl Bar; को let foo: impl Bar; के समान अर्थ का उपयोग करते हुए देखा है, यानी एक नया अज्ञात अस्तित्व प्रकार पेश करना; अपने उदाहरण को के बराबर बनाना

existential type _0: Bar;
type Foo = _0;
fn f() -> Foo { .. }
fn g() -> Foo { .. }

जो मुझे उम्मीद है कि अपेक्षाकृत स्पष्ट है।

एक मुद्दा यह है कि " impl Trait प्रकार के उपनामों में" का अर्थ कभी भी RFC में निर्दिष्ट नहीं किया गया है। इसका संक्षेप में RFC 2071 के "विकल्प" खंड में उल्लेख किया गया है, लेकिन इन अंतर्निहित शिक्षण अस्पष्टताओं के कारण स्पष्ट रूप से छूट दी गई है।

मुझे यह भी लगता है कि मैंने कुछ उल्लेख देखा है कि उपनाम पहले से ही संदर्भित रूप से पारदर्शी नहीं हैं। मुझे लगता है कि यह url.o पर था, लेकिन मुझे कुछ खोज के बाद चर्चा नहीं मिली।

@cramertj
@rpjohnst के बिंदु से अनुसरण करने के लिए, impl Trait के शब्दार्थ की कई व्याख्याएं हैं, जो सभी हस्ताक्षरों में वर्तमान उपयोग के अनुरूप हैं, लेकिन impl Trait को दूसरे तक विस्तारित करते समय अलग-अलग परिणाम होते हैं। स्थान (मैं पोस्ट में वर्णित एक के अलावा 2 के बारे में जानता हूं, लेकिन जो चर्चा के लिए बिल्कुल तैयार नहीं हैं)। और मुझे नहीं लगता कि यह सच है कि पोस्ट में व्याख्या अनिवार्य रूप से सबसे स्पष्ट है (मैंने व्यक्तिगत रूप से उस परिप्रेक्ष्य से एपीआईटी और आरटीआईपी के बारे में कोई समान स्पष्टीकरण नहीं देखा)।

type Foo: Bar = _; संबंध में, मुझे लगता है कि शायद इस पर फिर से चर्चा की जानी चाहिए - पुराने विचारों को नए सिरे से देखने में कोई बुराई नहीं है। इसके साथ आपके मुद्दों के बारे में:
(1) इसका कोई कीवर्ड नहीं है, लेकिन यह कहीं भी टाइप इंट्रेंस के समान सिंटैक्स है। "अंडरस्कोर"/"अंडरस्कोर टाइप"/आदि के लिए खोज दस्तावेज आसानी से टाइप अनुमान पर एक पेज प्रदान कर सकता है।
(2) हाँ, यह सच है। हम इसके समाधान के बारे में सोच रहे हैं, जो मुझे लगता है कि अंडरस्कोर नोटेशन के साथ अच्छी तरह से फिट बैठता है, जो उम्मीद है कि जल्द ही सुझाव देने के लिए तैयार होगा।

@Cramertj की तरह मैं वास्तव में यहाँ तर्क नहीं देख रहा हूँ।

मुझे वह मौलिक अस्पष्टता नहीं दिख रही है जो @varkor की पोस्ट का वर्णन करती है। मुझे लगता है कि हमने हमेशा रस्ट में "अस्तित्ववादी प्रकार" की व्याख्या की है "वहाँ एक _unique_ प्रकार मौजूद है ..." और न कि "कम से कम एक प्रकार मौजूद है ..." क्योंकि (जैसा कि @varkor की पोस्ट कहती है) उत्तरार्द्ध "सार्वभौमिक प्रकार" के बराबर है और इसलिए "अस्तित्ववादी प्रकार" वाक्यांश पूरी तरह से बेकार होगा यदि हम उस व्याख्या की अनुमति देने का इरादा रखते हैं। इस विषय पर प्रत्येक आरएफसी ने हमेशा सार्वभौमिक माना है और अस्तित्व के प्रकार दो अलग-अलग चीजें हैं। मुझे लगता है कि वास्तविक प्रकार के सिद्धांत में इसका मतलब है और वह समरूपता बहुत गणितीय रूप से वास्तविक है, लेकिन मेरे लिए यह सिर्फ एक तर्क है कि हम प्रकार सिद्धांत शब्दावली का दुरुपयोग कर रहे हैं और इसके लिए कुछ अन्य शब्दजाल चुनने की आवश्यकता है, तर्क नहीं कि impl Trait के इच्छित शब्दार्थ हमेशा अस्पष्ट थे और उन पर पुनर्विचार करने की आवश्यकता थी।

स्कोपिंग अस्पष्टता जो @rpjohnst वर्णन करती है वह एक गंभीर समस्या है, लेकिन प्रत्येक प्रस्तावित वाक्यविन्यास संभावित रूप से किसी भी प्रकार के एलिस या संबंधित प्रकारों के साथ भ्रमित है। उन भ्रमों में से कौन सा "बदतर" या "अधिक संभावना" है, वास्तव में कभी न खत्म होने वाला बाइकशेड है जिसे हम पहले ही कई सौ टिप्पणियों के बाद हल करने में विफल रहे हैं। मुझे यह पसंद है कि type Foo: Bar = _; किसी भी गैर-तुच्छ अस्तित्व को घोषित करने के लिए कई बयानों के विस्फोट की आवश्यकता की type Foo: Bar; की समस्या को ठीक करता प्रतीत होता है, लेकिन मुझे नहीं लगता कि यह वास्तव में बदलने के लिए पर्याप्त है "कभी-कभी बाइकशेड" स्थिति।

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

existential Foo = impl Trait;
fn f() -> Foo { .. }
fn g() -> Foo { .. }

existential Foo: Trait;
fn f() -> Foo { .. }
fn g() -> Foo { .. }



md5-b59626c5715ed89e0a93d9158c9c2535



existential Foo: Trait = _;
fn f() -> Foo { .. }
fn g() -> Foo { .. }

यह मेरे लिए स्पष्ट नहीं है कि इनमें से कोई भी पूरी तरह से _prevent_ गलत व्याख्या है कि f और g दो अलग-अलग प्रकारों को लागू कर सकता है Trait , लेकिन मुझे संदेह है कि यह रोकथाम के जितना करीब है हम संभवतः प्राप्त कर सकते हैं।

@Ixrec
वाक्यांश "अस्तित्ववादी प्रकार" विशेष रूप से स्कोपिंग अस्पष्टता के _क्योंकि_ समस्याग्रस्त है। मैंने किसी और को यह कहते हुए नहीं देखा कि एपीआईटी और आरपीआईटी के लिए दायरा पूरी तरह से अलग है। इसका मतलब है कि type Foo = impl Bar जैसा सिंटैक्स, जहां impl Bar एक "अस्तित्ववादी प्रकार" है, स्वाभाविक रूप से अस्पष्ट है।

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

स्कोपिंग अस्पष्टता जो @rpjohnst वर्णन करती है वह एक गंभीर समस्या है, लेकिन प्रत्येक प्रस्तावित वाक्यविन्यास संभावित रूप से किसी भी प्रकार के एलिस या संबंधित प्रकारों के साथ भ्रमित है। उन भ्रमों में से कौन सा "बदतर" या "अधिक संभावना" है, वास्तव में कभी न खत्म होने वाला बाइकशेड है जिसे हम पहले ही कई सौ टिप्पणियों के बाद हल करने में विफल रहे हैं।

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

मुझे इस बात का पूरा यकीन है कि हम जिस भी वाक्य रचना के साथ समाप्त होते हैं, उसके लिए type अलावा कोई अन्य कीवर्ड होना चाहिए

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

एक तरफ: एक तरफ ध्यान दें, मुझे लगता है कि पूरी तरह से "अस्तित्व के प्रकारों" से दूर जाना संभव है, जिससे पूरी स्थिति स्पष्ट हो जाती है, जिसे मैं या कोई और जल्द ही पालन करेगा।

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

मैंने किसी और को यह कहते हुए नहीं देखा कि एपीआईटी और आरपीआईटी के लिए दायरा पूरी तरह से अलग है।

मैंने सोचा था कि स्कोपिंग हमेशा निहित विशेषता प्रस्तावों का एक स्पष्ट हिस्सा था, इसलिए इसे "इंगित करने" की आवश्यकता नहीं थी। आपने स्कोपिंग के बारे में जो कुछ भी कहा है, ऐसा लगता है कि यह वही दोहरा रहा है जिसे हमने पहले ही पिछले RFC में स्वीकार कर लिया है। मुझे लगता है कि यह वाक्य रचना से सभी के लिए स्पष्ट नहीं है और यह एक समस्या है, लेकिन ऐसा नहीं है कि इससे पहले किसी ने इसे नहीं समझा। वास्तव में, मैंने सोचा था कि RFC 2701 पर चर्चा का एक बड़ा हिस्सा इस बारे में था कि type Foo = impl Trait; का दायरा क्या होना चाहिए, इस अर्थ में कि किस प्रकार का अनुमान है और इसे देखने की अनुमति नहीं है।

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

क्या आप यह कहने की कोशिश कर रहे हैं कि type Foo: Bar = _; वह वाक्य-विन्यास है, या आपको लगता है कि हमें वह अभी तक नहीं मिला है?

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

आपने पूरी तरह से नए नोटेशन का आविष्कार किया है

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

इसके बारे में सोचें, क्योंकि हम इस समय "अस्तित्व" का दुरुपयोग कर रहे हैं, इसका मतलब है कि existential Foo: Trait / = impl Trait शायद अब वैध वाक्यविन्यास नहीं हैं।

इसलिए हमें उन नामों के सामने एक नया कीवर्ड रखने की आवश्यकता है जो कुछ अज्ञात-से-बाहरी-कोड प्रकार को संदर्भित करते हैं ... और मैं इस पर एक रिक्त स्थान बना रहा हूं। alias , secret , internal , आदि सभी बहुत भयानक लगते हैं, और type से कम "विशिष्टता भ्रम" होने की संभावना नहीं है।

इसके बारे में सोचें, क्योंकि हम इस समय "अस्तित्व" का दुरुपयोग कर रहे हैं, इसका मतलब है कि existential Foo: Trait / = impl Trait शायद अब वैध वाक्यविन्यास नहीं हैं।

हां, मैं पूरी तरह से सहमत हूं - मुझे लगता है कि हमें "अस्तित्ववादी" शब्द से पूरी तरह से दूर जाने की जरूरत है* ( impl Trait अच्छी तरह से समझाते हुए इसे कैसे किया जाए, इसके लिए कुछ अस्थायी विचार हैं)।

*(संभवतः केवल dyn Trait लिए शब्द आरक्षित करना)

@joshtriplett , @Ixrec : मैं सहमत हूं कि _ संकेतन का अर्थ है कि आप अब उसी हद तक स्थानापन्न नहीं कर सकते हैं जो आप पहले कर सकते थे, और यदि इसे रखना प्राथमिकता है, तो हमें एक अलग सिंटैक्स की आवश्यकता होगी।

ध्यान रखें कि _ वैसे भी प्रतिस्थापन के संबंध में पहले से ही एक विशेष मामला है - यह केवल उपनाम टाइप नहीं है जो इसे प्रभावित करता है: कहीं भी आप वर्तमान में _ उपयोग कर सकते हैं, आप पूर्ण संदर्भित पारदर्शिता को रोक रहे हैं।

ध्यान रखें कि _ वैसे भी प्रतिस्थापन के संबंध में पहले से ही एक विशेष मामला है - यह केवल उपनाम टाइप नहीं है जो इसे प्रभावित करता है: कहीं भी आप वर्तमान में _ का उपयोग कर सकते हैं, आप पूर्ण संदर्भात्मक पारदर्शिता को रोक रहे हैं।

क्या आप हमें बता सकते हैं कि इसका वास्तव में क्या अर्थ है? मुझे "रेफ़रेंशियल ट्रांसपेरेंसी" की धारणा के बारे में पता नहीं था जो _ प्रभावित है।

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

मुझे यकीन नहीं है कि यह एक _प्राथमिकता_ है। मेरे लिए यह केवल एकमात्र उद्देश्य-आश तर्क था जिसे हमने कभी पाया था जो दूसरे पर एक वाक्यविन्यास पसंद करता था। लेकिन type को बदलने के लिए हम कौन से कीवर्ड लेकर आ सकते हैं, इसके आधार पर यह पूरी तरह बदल सकता है।

क्या आप हमें बता सकते हैं कि इसका वास्तव में क्या अर्थ है? मुझे "रेफ़रेंशियल ट्रांसपेरेंसी" की धारणा के बारे में पता नहीं था जो _ प्रभावित है।

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

रेफरेंशियल ट्रांसपेरेंसी से , इसका मतलब है कि इसकी परिभाषा के लिए एक संदर्भ को प्रतिस्थापित करना संभव है और इसके विपरीत शब्दार्थ में बदलाव के बिना। रस्ट में, यह स्पष्ट रूप से fn लिए टर्म लेवल पर नहीं है। उदाहरण के लिए:

fn foo() -> usize {
    println!("ey!");
    42
}

fn main() {
    let bar = foo();
    let baz = bar + bar;
}

यदि हम bar की प्रत्येक घटना को foo() ( bar की परिभाषा) से प्रतिस्थापित करते हैं, तो हमें स्पष्ट रूप से एक अलग आउटपुट मिलता है।

हालाँकि, टाइप उपनामों के लिए, इस समय रेफ़रेंशियल ट्रांसपेरेंसी होल्ड (AFAIK) है। यदि आपके पास उपनाम है:

type Foo = Definition;

तो फिर तुम क्या कर सकते हैं (पर कब्जा परहेज) के उत्पन्न होने की प्रतिस्थापन Foo के लिए Definition और के उत्पन्न होने की प्रतिस्थापन Definition के लिए Foo अपने कार्यक्रम के शब्दों को बदले बिना , या इसके प्रकार की शुद्धता।

परिचय:

type Foo = impl Bar;

इसका मतलब यह है कि Foo की प्रत्येक घटना एक ही प्रकार की है जिसका अर्थ है कि यदि आप लिखते हैं:

fn stuff() -> Foo { .. }
fn other_stuff() -> Foo { .. }

आप की घटनाओं को स्थानापन्न नहीं कर सकता Foo के लिए impl Bar और इसके विपरीत। यानी अगर आप लिखते हैं:

fn stuff() -> impl Bar { .. }
fn other_stuff() -> impl Bar { .. }

वापसी प्रकार Foo साथ एकीकृत नहीं होंगे। इस प्रकार उनके अंदर RFC 2071 के शब्दार्थ के साथ impl Trait पेश करके प्रकार के उपनामों के लिए संदर्भात्मक पारदर्शिता को तोड़ा गया है।

रेफ़रेंशियल पारदर्शिता और type Foo = _; जारी रखने के लिए... (@varkor द्वारा)

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

अच्छी बात। लेकिन क्या = _ असाइनमेंट बिट का अर्थ यह नहीं है कि यह केवल एक ही प्रकार है?

मैंने इसे पहले भी लिखा है, लेकिन...

पुन: संदर्भित पारदर्शिता: मुझे लगता है कि सी प्रीप्रोसेसर-जैसे प्रतिस्थापन के बजाय type को बाध्यकारी (जैसे let ) के रूप में देखना अधिक उपयोगी है। एक बार जब आप इसे इस तरह से देखते हैं, तो type Foo = impl Trait अर्थ ठीक वैसा ही होता है जैसा यह दिखता है।

मुझे लगता है कि शुरुआती लोगों के लिए impl Trait को अस्तित्वगत बनाम सार्वभौमिक प्रकार के रूप में सोचने की संभावना कम होगी, लेकिन "एक ऐसी चीज़ के रूप में जो impl sa विशेषता . If they want to know more, they can read the impl Trait` दस्तावेज़ीकरण। एक बार जब आप सिंटैक्स बदलें, आप इसके और मौजूदा सुविधा के बीच संबंध खो देते हैं और अधिक लाभ नहीं होता है। _आप केवल एक संभावित भ्रामक सिंटैक्स को दूसरे के साथ बदल रहे हैं।_

पुन type Foo = _ , यह पूरी तरह से असंबंधित अर्थ के साथ _ को अधिभारित करता है। यह दस्तावेज़ीकरण और/या Google में खोजने में भी मुश्किल लग सकता है।

@lnicola आप const बाइंडिंग के बजाय let बाइंडिंग के साथ भी जा सकते हैं, जहां पूर्व संदर्भित रूप से पारदर्शी है। let (जो fn अंदर संदर्भित रूप से पारदर्शी नहीं होता है) चुनना एक मनमाना विकल्प है जो मुझे नहीं लगता कि विशेष रूप से सहज है। मुझे लगता है कि प्रकार के उपनामों का सहज दृष्टिकोण यह है कि वे संदर्भित रूप से पारदर्शी हैं (भले ही उस शब्द का उपयोग न किया गया हो) क्योंकि वे उपनाम हैं ।

मैं सी प्रीप्रोसेसर प्रतिस्थापन के रूप में type को भी नहीं देख रहा हूं क्योंकि इसे जेनरिक से बचने और सम्मान करने पर कब्जा करना है (कोई SFINAE नहीं)। इसके बजाय, मैं type ठीक से सोच रहा हूं क्योंकि मैं इदरीस या अगडा जैसी भाषा में बाध्यकारी हूं जहां सभी बाइंडिंग शुद्ध हैं।

मुझे लगता है कि शुरुआती लोगों के लिए impl Trait को अस्तित्वगत बनाम सार्वभौमिक प्रकार के रूप में सोचने की संभावना कम होगी, लेकिन "एक ऐसी चीज जो एक विशेषता को दर्शाती है"

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

पुन type Foo = _ , यह पूरी तरह से असंबंधित अर्थ के साथ _ को अधिभारित करता है।

ऐसा कैसे? type Foo = _; यहां अन्य संदर्भों में _ के उपयोग के साथ संरेखित होता है जहां एक प्रकार की अपेक्षा की जाती है।
इसका अर्थ है "वास्तविक प्रकार का अनुमान लगाएं", जैसे कि जब आप .collect::<Vec<_>>() लिखते हैं।

यह दस्तावेज़ीकरण और/या Google में खोजने में भी मुश्किल लग सकता है।

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

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

@सेंट्रिल

ऐसा कैसे? type Foo = _; यहां अन्य संदर्भों में _ के उपयोग के साथ संरेखित होता है जहां एक प्रकार की अपेक्षा की जाती है।
इसका अर्थ है "वास्तविक प्रकार का अनुमान लगाएं", जैसे कि जब आप लिखते हैं .संग्रह ::>().

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

Google विशेष वर्णों को अनुक्रमित नहीं करता है।

यह अब सच नहीं है (हालांकि संभवतः व्हाइटस्पेस-निर्भर ..?)

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

type Foo = _; का सुझाया गया शब्दार्थ पूरी तरह से अनुमान पर आधारित अस्तित्वगत प्रकार के उपनाम के विकल्प के रूप में है। अगर यह पूरी तरह से स्पष्ट नहीं था, तो मैं जल्द ही कुछ ऐसा करने जा रहा हूं जो इरादों को थोड़ा बेहतर तरीके से समझाए।

@iopq हाल के परिवर्तनों के बारे में @varkor के नोट के अलावा, मैं इसे अन्य खोज इंजनों के लिए भी जोड़ना चाहूंगा, यह हमेशा संभव है कि आधिकारिक दस्तावेज़ीकरण और इस तरह स्पष्ट रूप से शाब्दिक शब्द "अंडरस्कोर" का उपयोग type के साथ संयोजन में करें

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

@सेंट्रिल

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

क्षमा करें, मैं अभी भी इसके चारों ओर अपना सिर नहीं लपेट सकता क्योंकि मेरा अंतर्ज्ञान पूरी तरह से पीछे की ओर है।

उदाहरण के लिए, यदि हमारे पास type Foo = Bar , तो मेरा अंतर्ज्ञान कहता है:
"हम Foo घोषित कर रहे हैं, जो Bar के समान प्रकार बन जाता है।"

फिर, अगर हम type Foo = impl Bar लिखते हैं, तो मेरा अंतर्ज्ञान कहता है:
"हम Foo घोषित कर रहे हैं, जो एक प्रकार बन जाता है जो Bar ।"

यदि Foo के लिए सिर्फ एक शाब्दिक उर्फ है impl Bar , तो वह मेरे लिए सुपर unintuitive होगी। मुझे इसे टेक्स्टुअल बनाम सिमेंटिक उपनाम के रूप में सोचना पसंद है।

तो अगर Foo को impl Bar बदला जा सकता है, तो यह कहीं भी दिखाई देता है, यह एक टेक्स्ट उपनाम है, जो मेरे लिए मैक्रोज़ और मेटाप्रोग्रामिंग की याद दिलाता है। लेकिन अगर Foo को घोषणा के बिंदु पर एक अर्थ सौंपा गया था और उस मूल अर्थ के साथ कई स्थानों पर उपयोग किया जा सकता है (प्रासंगिक अर्थ नहीं!), तो यह एक अर्थपूर्ण उपनाम है।

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

शायद मुझे मेरी गैर-हास्केल पृष्ठभूमि के कारण संदर्भात्मक पारदर्शिता अनजानी लगती है, कौन जानता है... :)

@Nemo157 @stjepang

यदि Foo वास्तव में एक अस्तित्वगत प्रकार के लिए एक प्रकार का उपनाम था

(जोर मेरा)। मैंने पढ़ा है कि 'ए' 'एक विशिष्ट' के रूप में जिसका अर्थ है f और g विभिन्न ठोस रिटर्न प्रकारों का समर्थन नहीं करेंगे, क्योंकि वे एक ही अस्तित्व के प्रकार को संदर्भित करते हैं।

यह "अस्तित्ववादी प्रकार" शब्द का दुरुपयोग है, या कम से कम एक ऐसा तरीका है जो @varkor की पोस्ट के type Foo = impl Bar बनाने के लिए प्रकट हो सकते हैं Foo प्रकार के लिए एक उपनाम ∃ T. T: Trait - और आप स्थानापन्न अगर ∃ T. T: Trait हर जगह आप का उपयोग Foo , यहां तक कि गैर -पाठ्य रूप से , आप प्रत्येक स्थिति में एक अलग ठोस प्रकार प्राप्त कर सकते हैं।

इस ∃ T क्वांटिफायर का दायरा (आपके उदाहरण में existential type _0 रूप में व्यक्त किया गया) प्रश्न की बात है। एपीआईटी में यह इस तरह तंग है- कॉलर किसी भी मूल्य को पारित कर सकता है जो ∃ T. T: Trait संतुष्ट करता है। लेकिन यह RPIT में नहीं है, और आरएफसी में नहीं 2071 के existential type घोषणाओं, और अपने desugaring में उदाहरण वहाँ नहीं, परिमाणक आगे, बाहर है पूरे समारोह या पूरे मॉड्यूल स्तर पर है, और आप के साथ सौदा वही T हर जगह।

इस प्रकार अस्पष्टता- हमारे पास पहले से ही impl Trait जो इसके क्वांटिफायर को उसकी स्थिति के आधार पर अलग-अलग स्थानों पर रखता है, इसलिए हमें type T = impl Trait लिए किसकी अपेक्षा करनी चाहिए? कुछ अनौपचारिक सर्वेक्षण, साथ ही RFC 2071 थ्रेड में प्रतिभागियों द्वारा कुछ तथ्य-प्राप्ति के बाद, यह साबित करते हैं कि यह एक या दूसरे तरीके से स्पष्ट नहीं है।

यही कारण है कि हम अस्तित्व के साथ कुछ भी करने के लिए impl Trait की व्याख्या से दूर जाना चाहते हैं, और इसके बजाय प्रकार के अनुमान के संदर्भ में इसके शब्दार्थ का वर्णन करते हैं। type T = _ में एक ही प्रकार की अस्पष्टता नहीं है- अभी भी सतह-स्तर है " _ के स्थान पर T _ को कॉपी-पेस्ट नहीं कर सकता," लेकिन अब और नहीं है " एकल प्रकार जो T का उपनाम है, का अर्थ कई ठोस प्रकार हो सकता है।" (अपारदर्शी/एकजुट नहीं होने वाला व्यवहार वह चीज है जिस पर @varkor अनुसरण करने की बात कर रहा है।)

संदर्भात्मक पारदर्शिता

सिर्फ इसलिए कि एक प्रकार का उपनाम वर्तमान में संदर्भात्मक पारदर्शिता के साथ संगत है, इसका मतलब यह नहीं है कि लोग इस सुविधा का पालन करने की अपेक्षा करते हैं।

एक उदाहरण के रूप में, const आइटम रेफरेंशियल ट्रांसपेरेंट है (इसका उल्लेख https://github.com/rust-lang/rust/issues/34511#issuecomment-402520768) है, और इससे वास्तव में नए और पुराने लोगों के लिए भ्रम पैदा हुआ है। उपयोगकर्ता (जंग-लंग-नर्सरी/जंग-क्लिप्पी#1560)।

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

@stjepang @kennytm मैं यह नहीं कह रहा हूं कि हर कोई उम्मीद करेगा कि उस प्रकार के उपनाम type Foo = impl Trait; के साथ एक संदर्भित पारदर्शी तरीके से कार्य करेंगे। लेकिन मुझे लगता है कि उपयोगकर्ताओं की एक गैर-तुच्छ राशि, जैसा कि इस धागे और अन्य जगहों में भ्रम से प्रमाणित है (जो

इस मामले में क्या किया जाना चाहिए, इस पर मेरी वर्तमान सोच @varkor और @rpjohnst के अनुरूप है।

पुन: संदर्भात्मक पारदर्शिता

type Foo<T> = (T, T);

type Bar = Foo<impl Copy>;   // not equivalent to (impl Copy, impl Copy)

दूसरे शब्दों में, यहां तक ​​​​कि हर उदाहरण पर नए प्रकार उत्पन्न करना सामान्य प्रकार के उपनामों के संदर्भ में संदर्भित रूप से पारदर्शी नहीं है।

@centril जब Foo में type Foo = impl Bar; लिए संदर्भात्मक पारदर्शिता की अपेक्षा करने की बात आती है तो मैं अपना हाथ उठाता हूं। हालांकि, type Foo: Bar = _; , मैं संदर्भात्मक पारदर्शिता की अपेक्षा नहीं करूंगा।

यह भी संभव है कि हम किसी भी प्रकार के enum impl Trait -समान तंत्र के बिना, कॉलर को मोनोमोर्फाइजिंग (टुकड़ों के) द्वारा, कई प्रकारों का समर्थन करने के लिए वापसी-स्थिति impl Trait बढ़ा सकते हैं। यह मजबूत " impl Trait व्याख्या हमेशा अस्तित्व है", यह के साथ लाइन में करीब लाता है dyn Trait , और पता चलता है एक abstract type सिंटैक्स का उपयोग नहीं करता impl Trait बिल्कुल भी।

मैंने इसे यहां इंटर्नल पर लिखा है: https://internals.rust-lang.org/t/extending-impl-trait-to-allow-multiple-return-types/7921

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

"अस्तित्ववादी" प्रकारों के बारे में बात करने से चीजें साफ होती नहीं दिख रही हैं। मैं कहूंगा कि impl Trait एक विशिष्ट, अनुमानित प्रकार को लागू करने वाली विशेषता के लिए है। इस तरह से वर्णित, type Foo = impl Bar स्पष्ट रूप से एक विशिष्ट, हमेशा समान, प्रकार है- और यह भी एकमात्र व्याख्या है जो वास्तव में उपयोगी है: इसलिए इसका उपयोग अन्य संदर्भों में किया जा सकता है, जिसके अलावा इसका अनुमान लगाया गया था, जैसे स्ट्रक्चर्स में।

इस अर्थ में, impl Trait को _ : Trait रूप में लिखना भी समझ में आता है।

@rpjohnst ,

यह भी संभव है कि हम कई प्रकारों का समर्थन करने के लिए वापसी-स्थिति impl Trait बढ़ा सकें

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

@ jan-hudec वे विचार डिस्कॉर्ड पर चर्चा में आए हैं, और कुछ मुद्दे हैं, मुख्य रूप से इस तथ्य के आधार पर कि वापसी-स्थिति और तर्क-स्थिति impl Trait की वर्तमान व्याख्या असंगत है।

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

उदाहरण के लिए, एक बार impl Trait अर्थ है "इस नए प्रकार के अनुमान का उपयोग एक बहुरूपी-जैसा-संभव प्रकार खोजने के लिए करें जो Trait ," type Foo = impl Bar मॉड्यूल के बारे में चीजों को इंगित करना शुरू कर देता है। abstract type का अनुमान लगाने के तरीके के बारे में RFC 2071 नियम कहता है कि सभी उपयोगों को स्वतंत्र रूप से एक ही प्रकार का अनुमान लगाना चाहिए, लेकिन यह बहुरूपी अनुमान कम से कम यह संकेत देगा कि अधिक संभव है। और अगर हमें कभी पैरामीट्रिज्ड मॉड्यूल मिले (यहां तक ​​​​कि सिर्फ जीवनकाल में, एक कहीं अधिक प्रशंसनीय विचार), तो उस बातचीत के आसपास प्रश्न होंगे।

एक तथ्य यह भी है कि कुछ लोग हमेशा type Foo = impl Bar वाक्य रचना को एक अस्तित्व के लिए उपनाम के रूप में व्याख्यायित करेंगे, भले ही वे "अस्तित्ववादी" शब्द को समझते हों और चाहे हम इसे कैसे भी पढ़ाते हों। तो एक वैकल्पिक वाक्यविन्यास चुनना, भले ही यह अनुमान-आधारित व्याख्या के साथ काम करने के लिए होता है, शायद अभी भी एक अच्छा विचार है।

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

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

वे विचार डिस्कॉर्ड पर चर्चा में आए हैं, और कुछ मुद्दे हैं, मुख्य रूप से इस तथ्य के आधार पर कि वापसी-स्थिति और तर्क-स्थिति impl Trait की वर्तमान व्याख्या असंगत है।

व्यक्तिगत रूप से, मुझे यह असंगति व्यवहार में कोई समस्या नहीं लगती। तर्क की स्थिति बनाम वापसी की स्थिति बनाम प्रकार की स्थिति के लिए ठोस प्रकार निर्धारित किए जाने का दायरा काफी सहज रूप से काम करता प्रतीत होता है।

मेरे पास एक ऐसा फ़ंक्शन है जहां कॉलर अपना रिटर्न प्रकार तय करता है। बेशक, मैं वहां इम्प्लांट ट्रैट का उपयोग नहीं कर सकता। जब तक आप अंतर को नहीं समझते, यह उतना सहज नहीं है जितना आप समझते हैं।

व्यक्तिगत रूप से, मुझे यह असंगति व्यवहार में कोई समस्या नहीं लगती।

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

@rpjohnst

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

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

@mikeyhew आप मुझे गलत समझते हैं- यह बंद या अन्य अज्ञात प्रकारों के लिए ठीक काम करता है, क्योंकि मैं आरएफसी 2071 abstract type वाक्यविन्यास के माध्यम से एक नाम का आविष्कार करने के बारे में बात कर रहा हूं। आप भले ही एक नाम का आविष्कार करने के लिए आप कहीं और ही प्रकार का उपयोग करने के लिए जा रहे हैं की है।

@rpjohnst ओह, मैं देखता हूं, स्पष्टीकरण के लिए धन्यवाद

let x: impl Trait बेसब्री से इंतज़ार है।

let x: impl Trait लिए एक और वोट के रूप में यह futures उदाहरणों में से कुछ को सरल बना देगा, यहां एक उदाहरण उदाहरण है , वर्तमान में यह केवल impl Trait का उपयोग करने की क्षमता प्राप्त करने के लिए फ़ंक्शन का उपयोग कर रहा है:

fn make_sink_async() -> impl Future<Output = Result<
    impl Sink<SinkItem = T, SinkError = E>,
    E,
>> { // ... }

इसके बजाय इसे सामान्य लेट बाइंडिंग के रूप में लिखा जा सकता है:

let future_sink: impl Future<Output = Result<
    impl Sink<SinkItem = T, SinkError = E>,
    E,
>> = // ...;

यदि वांछित हो तो मैं let x: impl Trait को लागू करके किसी को सलाह दे सकता हूं। यह करना असंभव रूप से कठिन नहीं है, लेकिन निश्चित रूप से आसान भी नहीं है। एक प्रवेश बिंदु:

इसी तरह हम https://github.com/rust-lang/rust/blob/master/src/librustc/hir/lowering.rs#L3159 में रिटर्न टाइप इम्प्लांट ट्रैट पर कैसे जाते हैं, हमें https में स्थानीय लोगों के प्रकार का दौरा करने की आवश्यकता है

फिर, स्थानीय लोगों के प्रकार पर जाकर, इसे वास्तव में सक्षम करने के लिए ExistentialContext से Return पर सेट करना सुनिश्चित करें।

यह हमें पहले से ही बहुत दूर ले जाना चाहिए। सुनिश्चित नहीं है कि सभी तरह से, यह वापसी की स्थिति की तरह 100% नहीं है, लेकिन ज्यादातर ऐसा व्यवहार करना चाहिए।

@rpjohnst ,

वे विचार कलह पर चर्चा में आए हैं, और कुछ मुद्दे हैं, मुख्य रूप से इस तथ्य के आधार पर कि वापसी-स्थिति और तर्क-स्थिति की वर्तमान व्याख्या विशेषता असंगत है।

हमें उन कार्यक्षेत्रों पर वापस ले जाता है जिनके बारे में आपने अपने लेख में बात की थी। और मुझे लगता है कि वे वास्तव में संलग्न "कोष्ठक" के अनुरूप हैं: तर्क स्थिति के लिए यह तर्क सूची है, वापसी की स्थिति के लिए यह कार्य है- और उपनाम के लिए यह वह दायरा होगा जिसमें उपनाम परिभाषित किया गया है।

मैंने एक आरएफसी खोला है जिसमें existential type कंक्रीट सिंटैक्स के लिए एक प्रस्ताव प्रस्तावित किया गया है, इस धागे में चर्चा के आधार पर, मूल आरएफसी और तुल्यकालिक चर्चा: https://github.com/rust-lang/rfcs/pull /2515.

वर्तमान अस्तित्व के प्रकार के कार्यान्वयन का उपयोग सभी मौजूदा रिटर्न स्थिति impl Trait परिभाषाओं का प्रतिनिधित्व करने के लिए नहीं किया जा सकता है, क्योंकि impl Trait प्रत्येक सामान्य प्रकार के तर्क को कैप्चर करता है, भले ही अप्रयुक्त हो, इसे existential type साथ करना संभव होना चाहिए (खेल का मैदान)

fn foo<T>(_: T) -> impl ::std::fmt::Display {
    5
}

existential type Bar<T>: ::std::fmt::Display;
fn bar<T>(_: T) -> Bar<T> {
    5
}

यह महत्वपूर्ण हो सकता है क्योंकि प्रकार पैरामीटर में आंतरिक जीवनकाल हो सकता है जो लौटाए गए impl Trait जीवनकाल को प्रतिबंधित करता है, भले ही मूल्य स्वयं अप्रयुक्त हो, खेल के मैदान में <T> से Bar को हटा दें यह देखने के लिए कि foo कॉल विफल हो जाती है लेकिन bar काम करती है।

वर्तमान अस्तित्व के प्रकार के कार्यान्वयन का उपयोग सभी वर्तमान रिटर्न स्थिति का प्रतिनिधित्व करने के लिए नहीं किया जा सकता है जिसमें विशेषता परिभाषाएं शामिल हैं

आप कर सकते हैं, यह बहुत ही असुविधाजनक है। आप PhantomData फ़ील्ड + वास्तविक डेटा फ़ील्ड के साथ एक नया प्रकार वापस कर सकते हैं और वास्तविक डेटा फ़ील्ड को अग्रेषित करने के रूप में विशेषता को कार्यान्वित कर सकते हैं

@ oli-obk अतिरिक्त सलाह के लिए धन्यवाद। आपकी पिछली सलाह और @cramertj से कुछ के साथ, मैं शायद जल्द ही इस पर जा सकता हूं।

@fasihrana @ Nemo157 ऊपर देखें। शायद कुछ हफ्तों में! :-)

क्या कोई स्पष्ट कर सकता है कि existential type का व्यवहार प्रकार के मापदंडों को परोक्ष रूप से कैप्चर नहीं कर रहा है (जो कि @ Nemo157 का उल्लेख किया गया है) जानबूझकर है और जैसा है वैसा ही रहेगा? मुझे यह पसंद है क्योंकि यह #42940 . को हल करता है

मैंने इसे इस तरह से बहुत उद्देश्य से लागू किया

@Arnavion हाँ, यह जानबूझकर किया गया है, और अन्य आइटम घोषणाओं (जैसे नेस्टेड फ़ंक्शंस) के रस्ट में काम करने के तरीके से मेल खाता है।

क्या existential_type और never_type के बीच बातचीत पर पहले ही चर्चा हो चुकी है?

हो सकता है कि ! शामिल लक्षणों की परवाह किए बिना किसी भी अस्तित्व के प्रकार को भरने में सक्षम होना चाहिए।

existential type Mystery : TraitThatIsHardToEvenStartImplementing;

fn hack_to_make_it_compile() -> Mystery { unimplemented!() }

या क्या कोई विशेष अछूत प्रकार होगा जो टाइप-लेवल unimplemented!() कर रहा है जो किसी भी अस्तित्वगत प्रकार को स्वचालित रूप से संतुष्ट करने में सक्षम है?

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

क्या ट्रेट मेथड रिटर्न टाइप्स को जल्द ही समर्थन देने की कोई योजना है?

existential type पहले से ही विशेषता विधियों के लिए काम करता है। Wrt impl Trait , क्या वह भी RFC द्वारा कवर किया गया है?

@alexreg मेरा मानना ​​​​है कि जब आपके पास fn foo<T>(..) -> impl Bar<T> (लगभग -> Self::AnonBar0<T> ) जैसा कुछ होता है तो GATs को एक अज्ञात संबद्ध प्रकार में desugar करने में सक्षम होने की आवश्यकता होती है।

@Centril क्या आपका मतलब <T> पर impl Bar था? impl Trait निहित प्रकार के कैप्चर व्यवहार का अर्थ है कि आपको fn foo<T>(self, t: T) -> impl Bar; जैसी किसी चीज़ के साथ भी GAT की समान आवश्यकता मिलती है।

@ Nemo157 नहीं, क्षमा करें मैंने नहीं किया। लेकिन आपका उदाहरण समस्या को और भी बेहतर तरीके से दिखाता है। आपको धन्यवाद :)

@alexreg मेरा मानना ​​​​है कि जब आपके पास fn foo जैसा कुछ होता है, तो GAT को एक अनाम संबद्ध प्रकार के लिए सक्षम होने की आवश्यकता होती है(..) -> impl Bar(मोटे तौर पर हो जाता है -> Self::AnonBar0)

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

ट्राइएज: https://github.com/rust-lang/rust/pull/53542 को मर्ज कर दिया गया है, इसलिए मुझे लगता है कि {let,const,static} foo: impl Trait के टिक बॉक्स को चेक किया जा सकता है।

क्या मैं कभी लिख पाऊंगा:

trait Foo {
    fn GetABar() -> impl Bar;
}

??

शायद नहीं। लेकिन सब कुछ तैयार करने की योजनाएँ चल रही हैं ताकि हमें मिल सके

trait Foo {
    type Assoc: Bar;
    fn get_a_bar() -> Assoc;
}

impl Foo for SomeType {
    fn get_a_bar() -> impl Bar {
        SomeThingImplingBar
    }
}

आप इस सुविधा के साथ रात में के रूप में प्रयोग कर सकते हैं

impl Foo for SomeType {
    existential type Assoc;
    fn get_a_bar() -> Assoc {
        SomeThingImplingBar
    }
}

इसके बारे में अधिक जानकारी प्राप्त करने के लिए एक अच्छी शुरुआत है https://github.com/rust-lang/rfcs/pull/2071 (और इससे जुड़ी हर चीज)

@ oli-obk rustc 1.32.0-nightly (00e03ee57 2018-11-22) , मुझे impl ब्लॉक में काम करने के लिए existential type लिए विशेषता सीमाएं भी देनी होंगी। क्या यह अपेक्षित है?

@jonhoo लक्षणों को निर्दिष्ट करने में सक्षम होना उपयोगी है क्योंकि आप केवल आवश्यक लक्षणों से अधिक प्रदान कर सकते हैं

impl Foo for SomeDebuggableType {
    existential type Assoc: Bar + Debug;
    fn get_a_bar() -> Assoc {
        SomeThingImplingBarAndDebug
    }
}

fn use_debuggable_foo<F>(f: F) where F: Foo, F::Assoc: Debug {
    println!("bar is: {:?}", f.get_a_bar())
}

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

@ Nemo157 आह, क्षमा करें, मेरा मतलब यह है कि वर्तमान में आप _must_ की सीमाएँ हैं। यही है, यह संकलित नहीं होगा:

impl A for B {
    existential type Assoc;
    // ...
}

जबकि यह होगा:

impl A for B {
    existential type Assoc: Debug;
    // ...
}

ओह, तो उस स्थिति में भी जहां किसी विशेषता को संबंधित प्रकार की कोई सीमा की आवश्यकता नहीं होती है, फिर भी आपको अस्तित्व के प्रकार (जो खाली हो सकता है) ( खेल का मैदान ) के लिए बाध्य होना चाहिए:

trait Foo {
    type Assoc;
    fn foo() -> Self::Assoc;
}

struct Bar;
impl Foo for Bar {
    existential type Assoc: ;
    fn foo() -> Self::Assoc { Bar }
}

यह मेरे लिए एक किनारे के मामले की तरह लगता है, एक बाध्य-कम अस्तित्व के प्रकार का मतलब है कि यह उपयोगकर्ताओं को _no_ संचालन प्रदान करता है (ऑटो-लक्षणों के अलावा), तो इसका क्या उपयोग किया जा सकता है?

यह भी ध्यान देने योग्य है कि -> impl Trait साथ ऐसा करने का कोई तरीका नहीं है, -> impl () एक सिंटैक्स त्रुटि है और -> impl अपने आप में error: at least one trait must be specified ; यदि अस्तित्वगत प्रकार का सिंटैक्स type Assoc = impl Debug; या समान हो जाता है तो ऐसा लगता है कि संबंधित प्रकार को कम से कम एक विशेषता बाध्य किए बिना निर्दिष्ट करने का कोई तरीका नहीं होगा।

@ Nemo157 हाँ, मुझे केवल इसलिए एहसास हुआ क्योंकि मैंने आपके द्वारा ऊपर सुझाए गए कोड का शाब्दिक रूप से प्रयास किया था, और यह काम नहीं किया: p मुझे लगता है कि यह विशेषता से सीमा का अनुमान लगाएगा। उदाहरण के लिए:

trait Foo {
    type Assoc: Future<Output = u32>;
}

struct Bar;
impl Foo for Bar {
    existential type Assoc;
}

दूसरी बार Future<Output = u32> निर्दिष्ट नहीं करना उचित प्रतीत होता है, लेकिन यह काम नहीं करता है। मुझे लगता है कि existential type Assoc: ; (जो सुपर अजीब सिंटैक्स की तरह भी लगता है) उस अनुमान को भी नहीं करेगा?

trait Foo {
    type Assoc;
    fn foo() -> Self::Assoc;
}

struct Bar;
impl Foo for Bar {
    existential type Assoc: ;
    fn foo() -> Self::Assoc { Bar }
}

यह मेरे लिए एक किनारे के मामले की तरह लगता है, एक बाध्य-कम अस्तित्व के प्रकार का मतलब है कि यह उपयोगकर्ताओं को _no_ संचालन प्रदान करता है (ऑटो-लक्षणों के अलावा), तो इसका क्या उपयोग किया जा सकता है?

क्या इनका उपयोग समान विशेषता कार्यान्वयन में उपभोग के लिए नहीं किया जा सकता था? कुछ इस तरह:

trait Foo {
    type Assoc;
    fn create_constructor() -> Self::Assoc;
    fn consume(marker: Self::Assoc) -> Self;
    fn consume_box(marker: Self::Assoc) -> Box<Foo>;
}

यह थोड़ा सा काल्पनिक है, लेकिन यह उपयोगी हो सकता है - मैं ऐसी स्थिति की कल्पना कर सकता हूं जहां कुछ प्रारंभिक भाग को वास्तविक संरचना से पहले आजीवन कारणों से बनाया जाना चाहिए। या यह कुछ ऐसा हो सकता है:

trait MarkupSystem {
    type Cache;
    fn create_cache() -> Cache;
    fn translate(cache: &mut Self::Cache, input: &str) -> String;
}

इन दोनों ही मामलों में existential type Assoc; उपयोगी होगा।

अंतर्निहित विशेषता के लिए संबद्ध प्रकारों को परिभाषित करने का उचित तरीका क्या है?

उदाहरण के लिए, यदि मेरे पास Action विशेषता है और मैं यह सुनिश्चित करना चाहता हूं कि विशेषता के संबंधित प्रकार का कार्यान्वयन भेजने योग्य है, तो क्या मैं ऐसा कुछ कर सकता हूं:

pub trait Action {
    type Result;
    fn call(&self) -> Self::Result;
}

impl MyStruct {
    pub fn new(name: String) -> impl Action 
    where 
        Return::Result: Send //This Return should be the `impl Action`
    {
        ActionImplementation::new()
    }
}

क्या ऐसा कुछ वर्तमान में संभव नहीं है?

@acyclozebra मुझे लगता है कि इसके लिए वाक्यविन्यास -> impl Action<Result = impl Send> - यह वही वाक्यविन्यास है, उदाहरण के लिए, -> impl Iterator<Item = u32> सिर्फ एक और अज्ञात impl Trait प्रकार का उपयोग कर।

क्या स्ट्रक्चर फ़ील्ड जैसी चीज़ों के लिए impl Trait सिंटैक्स को विस्तारित करने के बारे में कोई चर्चा हुई है? उदाहरण के लिए, यदि मैं अपने सार्वजनिक इंटरफ़ेस के लिए एक विशिष्ट इटरेटर प्रकार के चारों ओर एक रैपर लागू कर रहा हूं:

struct Iter<'a> {
    inner: std::collections::hash_map::Iter<'a, i32, i32>,
}

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

हालांकि आईआईआरसी, मुझे नहीं लगता कि इस समय impl Trait साथ कई सीमाएं निर्दिष्ट करने का कोई तरीका है, इसलिए मैं Clone जैसी कुछ उपयोगी चीजें खो

@AGausmann इस विषय पर नवीनतम चर्चा https://github.com/rust-lang/rfcs/pull/2515 में है। यह आपको type Foo = impl Bar; struct Baz { field: Foo } ... कहने की अनुमति देगा। मुझे लगता है कि हम विचार कर सकते हैं field: impl Trait स्थिर के बाद उस के लिए चीनी के रूप में type Foo = impl Bar; । यह एक उचित मैक्रो-फ्रेंडली सुविधा-विस्तार की तरह महसूस करता है।

@सेंट्रिल ,

मुझे लगता है कि हम चीनी के रूप में field: impl Trait पर विचार कर सकते हैं

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

यह इसका अनुमान लगा सकता है, लेकिन यदि आपके पास एकाधिक कार्य हैं तो यह पता लगाना इतना आसान नहीं होगा कि यह कौन सा है

आप मूल प्रकार के उपयोग को परिभाषित करने की आवश्यकता को पूरा करेंगे। यह तब उसी मॉड्यूल में वे सभी कार्य होंगे जो मूल प्रकार लौटाते हैं। मुझे यह सब खोजना इतना कठिन नहीं लगता। मुझे लगता है कि हालांकि हम विस्तार के साथ आगे बढ़ने से पहले कहानी को type Foo = impl Bar; पर व्यवस्थित करना चाहते हैं।

मुझे लगता है कि मुझे वर्तमान existential type कार्यान्वयन में एक बग मिला।

trait Collection {
    type Element;
}
impl<T> Collection for Vec<T> {
    type Element = T;
}

existential type Existential<T>: Collection<Element = T>;

fn return_existential<I>(iter: I) -> Existential<I::Item>
where
    I: IntoIterator,
    I::Item: Collection,
{
    let item = iter.into_iter().next().unwrap();
    vec![item]
}

error: type parameter `I` is part of concrete type but not used in parameter list for existential type
  --> src/lib.rs:16:1
   |
16 | / {
17 | |     let item = iter.into_iter().next().unwrap();
18 | |     vec![item]
19 | | }
   | |_^

error: defining existential type use does not fully define existential type
  --> src/lib.rs:12:1
   |
12 | / fn return_existential<I>(iter: I) -> Existential<I::Item>
13 | | where
14 | |     I: IntoIterator,
15 | |     I::Item: Collection,
...  |
18 | |     vec![item]
19 | | }
   | |_^

error: could not find defining uses
  --> src/lib.rs:10:1
   |
10 | existential type Existential<T>: Collection<Element = T>;
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

खेल का मैदान

आप इसे स्टैक ओवरफ्लो पर भी पा सकते हैं।

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

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

fn return_existential<I, J>(iter: I) -> Existential<J>
where
    I: IntoIterator<Item = J>,
{
    let item = iter.into_iter().next().unwrap();
    vec![item]
}