Rust: और स्वयं के साथ परस्पर आत्म-उधार संघर्ष।

मेरा मानना ​​है कि यह सही व्यवहार है। यह देखने के लिए कि, स्पष्ट जीवनकाल एनोटेशन वाले कोड पर विचार करें:

struct A {
    a: i32
}

impl A {
    fn one<'a>(&'a mut self) -> &'a i32{
        self.a = 10;
        &self.a
    }
    fn two<'a>(&'a mut self) -> &'a i32 {
        loop {
            let k = self.one();
            if *k > 10i32 {
                return k;
            }
        }
    }
}

two को एक ही जीवनकाल के साथ एक संदर्भ को वापस करने की आवश्यकता है, जैसा कि इसे दिए गए उत्परिवर्तित उधार के रूप में है। हालाँकि, जब से यह हो जाता है। इसका मतलब है कि k का जीवनकाल 'a होना चाहिए। हालाँकि, one के लौटाए गए मूल्य के लिए, जीवनकाल 'a , one के इनपुट का भी जीवनकाल 'a होना चाहिए। इसका मतलब यह है कि रस्ट को self "रीबोर" नहीं करने के लिए मजबूर किया जाता है और इसे one में स्थानांतरित कर दिया जाता है। चूंकि उत्परिवर्तनीय संदर्भ रैखिक होते हैं, उन्हें केवल एक बार स्थानांतरित किया जा सकता है, लेकिन loop अर्थ है कि one को एक ही परस्पर संदर्भ के साथ बार-बार कॉल करने की आवश्यकता हो सकती है।

दूसरा उदाहरण केवल इसलिए काम करता है क्योंकि रस्ट देख सकता है कि लूप केवल एक बार चलेगा, इसलिए self केवल एक बार चले जाएंगे।

यह एक गैर-शाब्दिक उधार मुद्दे की तरह दिखता है। आप बिना किसी छोरों के समान व्यवहार प्राप्त कर सकते हैं:

struct Foo { data: Option<i32> }

fn main() {
    let mut x = Foo{data: Some(1)};

    foo(&mut x);
}

fn foo(x: &mut Foo) -> Option<&mut i32> {
    if let Some(y) = x.data.as_mut() {
        return Some(y);
    }

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

<anon>:14:22: 14:28 error: cannot borrow `x.data` as immutable because it is also borrowed as mutable
<anon>:14     println!("{:?}", x.data); 
                               ^~~~~~
note: in expansion of format_args!
<std macros>:2:43: 2:76 note: expansion site
<std macros>:1:1: 2:78 note: in expansion of println!
<anon>:14:5: 14:30 note: expansion site
<anon>:10:22: 10:28 note: previous borrow of `x.data` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x.data` until the borrow ends
<anon>:10     if let Some(y) = x.data.as_mut() {
                               ^~~~~~
<anon>:16:2: 16:2 note: previous borrow ends here
<anon>:9 fn foo(x: &mut Foo) -> Option<&mut i32> {
...
<anon>:16 }
          ^
error: aborting due to previous error

Rustc सशर्त उधार रिटर्न के साथ "सौदा" नहीं कर सकता है।

सीसी @ पीसीवल्टन

मुझे लगता है कि मुद्दा वास्तव में यह है कि रिटर्न वैल्यू की उत्परिवर्तन का उपयोग नहीं किया जाता है, लेकिन फ़ंक्शन तर्क की उत्परिवर्तन।

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

struct Foo (u8);

impl Foo {
    fn bar(&mut self) -> &u8 {
        self.0 += 1;
        &self.0
    }
}

fn main() {
    let mut x = Foo(42);
    let a = x.bar(); // note: borrow of `x` occurs here
    let b = x.0; // error: cannot use `x.0` because it was mutably borrowed
}

प्लेपेन

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

यदि आप @Gankro के उदाहरण पर एक नज़र उधारकर्ता को पास करता है यदि आप रिटर्न कीवर्ड हटाते हैं, भले ही परिणामी फ़ंक्शन ठीक से काम नहीं करेगा।

यह गैर-शाब्दिक जीवनकाल पर अवरुद्ध है, जो बदले में एमआईआर पर अवरुद्ध है। आदर्श रूप से यह 2016 के अंत तक तय हो जाएगा, लेकिन एक फिक्स जल्द ही नहीं उतरेगा।

इंटर्नल पर कुछ चर्चा: https://internals.rust-lang.org/t/relaxing-the-borrow-checker-for-fn-mut-self-t/3256

गैर-शाब्दिक उधार सुविधा चर्चा: https://github.com/rust-lang/rfcs/issues/811

इसलिए [इंटर्नल थ्रेड] को पढ़ने से मुझे लगता है कि यह ठीक नहीं है (एनएलएल के साथ भी)। क्या कोई पुष्टि कर सकता है? (@ ईडबीबी?)

cc @ रेस्ट-लॉन्ग / लॉन्ग

यह वास्तव में एनएलएल है और, अगर मुझसे गलती नहीं होती है, तो यह मेरे द्वारा किए गए विभिन्न प्रस्तावों द्वारा तय किया जाएगा। यह मोटे तौर पर मेरे पहले ब्लॉग पोस्ट से "समस्या केस # 3" से मेल खाता है। मूल विचार (के मामले में नवीनतम ब्लॉग पोस्ट से तैयार क्यों यह काम करेगा की) है कि subtyping उधार केवल के अंत तक विस्तार करने के लिए की आवश्यकता होगी 'a की शाखा में if जो return कारण बनता है।

@nikomatsakis क्या आप इस बारे में अधिक विस्तार से &mut संदर्भों के मेरे मानसिक मॉडल में, उन्हें या तो मूव या रीबोर करके पास किया जा सकता है, और इस समस्या में समस्या यह है कि वापसी के लिए मूव मोड की आवश्यकता होती है, और self का पुनः उपयोग होता है। बाद में पुनर्जन्म की आवश्यकता reborrowed &mut संदर्भ के जीवनकाल चर धारण के जीवनकाल के द्वारा सीमित है &mut -reference - इस मामले में, self चर, इस प्रकार यह द्वारा सीमित है फ़ंक्शन का शरीर, इस प्रकार यह फ़ंक्शन कॉल के बाहर का विस्तार नहीं कर सकता है। क्या एनएलएल उस सीमा को बदलने जा रही है (या शायद ऐसी कोई सीमा नहीं है)?

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

इसके अलावा, यदि एनएलएल इस मुद्दे को ठीक करने जा रहा है, तो क्या इसका मतलब है कि एनएलएल के तहत आपको कभी भी एक चाल और रीब्रो के बीच चयन नहीं करना पड़ेगा?

क्या यह जल्द ही तय होने वाला है?

@krdln

क्या आप इस बारे में अधिक विस्तार से बता सकते हैं कि एनएलएल इस मुद्दे पर कैसे बातचीत करता है?

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

अधिक विस्तार से, यदि आप यहाँ विस्तृत हस्ताक्षर लेते हैं, तो आप देख सकते हैं कि हमें जीवन भर के साथ 'a एक संदर्भ वापस करना होगा:

fn two<'a>(&'a mut self) -> &'a i32 { .. }

अब निरीक्षण करें कि हम let k = self.one() और फिर इस k । इसका मतलब है कि के प्रकार k होना चाहिए &'a i32 । बदले में इसका मतलब है कि जब हम self.one() कॉल करते हैं, तो हमें इसे self प्रकार के &'a mut Self साथ उधार देना होगा। इसलिए, let k = self.one() हम जीवन भर 'a साथ self का ऋण जारी करते हैं। यह जीवनकाल लूप (और, वास्तव में, संपूर्ण फ़ंक्शन) से बड़ा है, इसलिए यह तब तक बना रहता है जब हम लूप के चारों ओर जाते हैं, त्रुटि रिपोर्ट के लिए अग्रणी। मेरे द्वारा प्रस्तावित NLL नियमों के तहत, k का जीवनकाल केवल 'a का विस्तार करने के लिए आवश्यक है यदि if लिया जाता है। इसलिए, यदि if नहीं लिया जाता है, तो ऋण पहले समाप्त हो सकता है।

क्या उससे मदद हुई?

@ ओसा 1

क्या यह जल्द ही तय होने वाला है?

इससे पहले कि हम ऐसा कर सकें, अभी भी कुछ कदम हैं, लेकिन आवश्यक रिफ्लेक्टरिंग करने पर सक्रिय काम करना है।

@ मुिनकोमातसकिस
धन्यवाद, यह कुछ हद तक मदद की। वास्तव में होता क्या है जब आप लिखते हैं - लेकिन एक छोटी सी बात यह है कि मुझे समझ नहीं आता है self अपने कोड में - कैसे की reborrow self काम करता है। मैंने "समस्या का मामला 3" ( get_default ) का आपका एक्सप्लेनेशन पढ़ा है, जहाँ आप कॉलर के अंदर कोड को इनलाइन करते हैं, लेकिन वहाँ, आपने self हर उपयोग को उधार लेने में बदल दिया है। map चर सीधे, ताकि desugaring मेरे लिए यह स्पष्ट नहीं किया।

यहां बताया गया है कि मैं कहां फंस गया हूं: जब हम let k = self.one() कॉल करते हैं, तो self को स्थानांतरित नहीं किया जा सकता (क्योंकि बाद में इसकी आवश्यकता होती है), इसलिए इसे उधार माना जाता है। बाद में, हम सशर्त रूप से उस k वापस कर देते हैं, ताकि उधार के लिए जीवन भर 'a लगें, जो फ़ंक्शन कॉल की रूपरेखा तैयार करता है। परंतु! हमने self से उधार लिया है, जो केवल फ़ंक्शन के अंत तक रहता है। यह सीमा 'a कम करने के लिए लगती है, इसलिए मेरे मानसिक मॉडल में, यहां तक ​​कि एनएलएल के तहत, हमें "लंबे समय तक जीवित नहीं रहना चाहिए" त्रुटि।

@krdln हमने वास्तव में *self से उधार लिया है - अर्थात, हमने यह स्वीकार कर लिया है कि आत्म क्या संदर्भित करता है। हम आपको जीवन भर self देने के लिए *self उधार लेने की अनुमति देते हैं क्योंकि self का प्रकार पूरे जीवनकाल 'a लिए 'लॉक' का अर्थ है। इसलिए, जब तक हम यह गारंटी दे सकते हैं कि 'a , स्वयं का उपयोग नहीं किया जाता है, परिणाम एक विशेष संदर्भ होना चाहिए - इस मामले में, fn रिटर्न के बाद, स्वयं को पॉप किया गया है, और इसलिए यह हो सकता है उपयोग नहीं किया जा सकता है, इसलिए केवल इस बात की गारंटी है कि fn के अंत तक स्वयं का उपयोग नहीं किया जाता है। (कम से कम मुझे आशा है कि यह सच है। =)

यह गैर-शाब्दिक जीवनकाल पर अवरुद्ध है, जो बदले में एमआईआर पर अवरुद्ध है। आदर्श रूप से यह 2016 के अंत तक तय हो जाएगा, लेकिन एक फिक्स जल्द ही नहीं उतरेगा।

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

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

मुझे यह भी उल्लेख करना चाहिए कि अभिनीत कोड अब नवीनतम रात्रिकालीन संकलन नहीं है। @ रॉबर्टियन ने " regression-from-nightly-to-nightly " टैग का सुझाव दिया, और यह भी सुझाव दिया गया था कि मुझे @nikomatsakis को टैग करना चाहिए अगर यह एक जरूरी समस्या थी :)

इस मुद्दे पर बहुत कुछ करने की कोशिश कर रहा है (जो वर्तमान nll द्वारा अनुमति नहीं है) ठोकर खाई:

fn f(vec: &mut Vec<u8>) -> &u8 {
    if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
        *n = 10;
        n
    } else {
        vec.push(10);
        vec.last().unwrap()
    }
}

fn main() {
    let mut vec = vec![1, 2, 3];
    f(&mut vec);
}

error[E0499]: cannot borrow `*vec` as mutable more than once at a time
 --> src/main.rs:6:9
  |
1 | fn f(vec: &mut Vec<u8>) -> &u8 {
  |           - let's call the lifetime of this reference `'1`
2 |     if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
  |                      --- first mutable borrow occurs here
3 |         *n = 10;
4 |         n
  |         - returning this value requires that `*vec` is borrowed for `'1`
5 |     } else {
6 |         vec.push(10);
  |         ^^^ second mutable borrow occurs here

error[E0502]: cannot borrow `*vec` as immutable because it is also borrowed as mutable
 --> src/main.rs:7:9
  |
1 | fn f(vec: &mut Vec<u8>) -> &u8 {
  |           - let's call the lifetime of this reference `'1`
2 |     if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
  |                      --- mutable borrow occurs here
3 |         *n = 10;
4 |         n
  |         - returning this value requires that `*vec` is borrowed for `'1`
...
7 |         vec.last().unwrap()
  |         ^^^ immutable borrow occurs here

(हमें एनएलएल-फिक्स्ड-एनएलएल को हटाते समय ई-जरूरतमंद को हटा देना चाहिए था)