नक्शा बंद होने के भीतर एक ही प्रकार के ज़िपिंग वैक्टर अलग-अलग प्रकार के होते हैं

Aug 16 2020

पृष्ठभूमि

एक एनुम प्रकार (गैर-प्रतिलिपि योग्य) को देखते हुए:

enum AstNode {
  Op(Func, Box<AstNode>, Box<AstNode>),
  Val(f64),
  // others...
}

ऐसे दो वैक्टरों पर एक ऑपरेशन चलाने का प्रयास किया जा रहा है:

fn apply_func_iterative(func: Func, lhs: Vec<AstNode>, rhs: Vec<AstNode>) -> Vec<AstNode> {
    lhs.iter().zip(rhs).map(|(&l,r)| apply_func(func,l,r)).collect()  // l and r are declared differently!
}

fn apply_func(func: Func, lhs: AstNode, rhs: AstNode) -> AstNode {
    // magic happens here!
}

बंद होने के भीतर, lhsतत्व टाइप करते हैं l: &AstNodeजबकि ज़िप किए गए rhsतत्व टाइप करते हैं l: AstNode। (क्लोजर ट्यूपल में विभिन्न घोषणाओं पर ध्यान दें)।

प्रशन

यह एक केस क्यों है?

क्या संदर्भ के बजाय मूल्य द्वारा वेक्टर के तत्वों को पुनरावृत्त करने का एक तरीका है? ऐसा लगता है कि ज़िपित तत्वों के देखे गए व्यवहार से यह संभव है।

(इस उदाहरण में, इस अंतर के कारण वाक्यविन्यास घोषणा में थोड़ी विषमता होती है, लेकिन व्यवहार में, मैंने संदर्भ चर को एक फ़ंक्शन में पास करते समय उधारकर्ता के खिलाफ मारा है)

अस्वीकरण: मैं जंग के लिए काफी नया हूं

जवाब

6 kmdreko Aug 16 2020 at 04:55

Iterator::zipविधि कुछ विशेष कर रही है, यह केवल दोनों iterators संयोजन है नहीं है। आपको लगता है कि पता लगा रहे हैं lhs.iter()पैदावार एक Iterator<&AstNode>जबकि rhsपैदावार एक Iterator<AstNode>( &बनाम गैर &)।

क्या संदर्भ के बजाय मूल्य द्वारा वेक्टर के तत्वों को पुनरावृत्त करने का एक तरीका है? ऐसा लगता है कि ज़िपित तत्वों के देखे गए व्यवहार से यह संभव है।

हां, इस व्यवहार को नियंत्रित करने का एक तरीका है। यह देखना महत्वपूर्ण है कि zip()तर्क rhsको लागू करना चाहिए IntoIterator। अंततोगत्वा, इससे एक पुनरावृत्ति प्राप्त करने के लिए zip()कॉल करेगा rhs.into_iter()। पारंपरिक व्यवहार यह है कि .iter()केवल स्रोत उधार लेता है और इसलिए केवल अपने मूल्यों को संदर्भ प्रदान कर सकता है। जबकि खपत या " स्रोत का स्वामित्व लेता है" और स्वामित्व मूल्यों को प्राप्त कर सकता है।.into_iter()

उन लोगों को मिलाकर, आप संदर्भों पर पुनरावृत्ति प्राप्त करने के लिए lhs.into_iter().zip(rhs)मूल्यों पर एक पुनरावृत्ति प्राप्त करने (AstNode, AstNode)या उपयोग lhs.iter().zip(rhs.iter())करने के लिए कर सकते हैं (&AstNode, &AstNode)