जंग के ऑपरेटरों के पास आउटपुट चर प्रकार क्यों है?

Question

मैं ऑनलाइन जंग के माध्यम से पढ़ रहा हूं और मैं 4.1, Operators and Overloading पर पहुंच गया हूं। मैंने देखा कि std::ops::Add इसे fn add(self, rhs: RHS) -> Self::Output; के रूप में परिभाषित करता है जिसमें type Output विशेषता में अलग से परिभाषित किया गया है।

मैं समझता हूँ कि यहाँ क्या हो रहा है: add समारोह self के रूप में बाएं हाथ की ओर, और सामान्य पैरामीटर प्रकार RHS के रूप में दाहिने हाथ की ओर स्वीकार करता है।

मैं जानना चाहता हूं कि Output उपनाम के साथ आउटपुट प्रकार क्यों परिभाषित किया गया है, एक और सामान्य (उदा। Add<RHS, Output>) होने के बजाय? क्या यह सिर्फ एक सम्मेलन है, या इसके लिए कोई विशिष्ट कारण है?

Answer 1

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

Output के बाद से एक संबद्ध प्रकार, दो प्रकार के A और B कि हम impl Add करना चाहते हैं के लिए है, हम एक ही Output प्रकार उठा तक ही सीमित हैं। Output एक प्रकार पैरामीटर थे, हम impl AddA और B के असंख्य तरीके से कर सकते थे।

trait Mul<RHS, Output> { 
    fn mul(self, rhs: RHS) -> Output; 
} 

अब एक Complex प्रकार को परिभाषित करते हैं:

#[derive(Debug, Clone, Copy)] 
struct Complex { 
    x: f64, 
    y: f64, 
} 

impl Complex { 
    fn new(x: f64, y: f64) -> Complex { 
     Complex { x: x, y: y } 
    } 
} 

हम से गुणा करने के लिए सक्षम होना चाहते हैं

उदाहरण के लिए, हमें एक Mul विशेषता जहां Output एक पैरामीटर है निर्दिष्ट कर सकते हैं f64:

impl Mul<f64, Complex> for Complex { 
    fn mul(self, rhs: f64) -> Complex { 
     Complex::new(self.x * rhs, self.y * rhs) 
    } 
} 

यह सब ठीक काम करता है। हालांकि, हम एक दूसरे कार्यान्वयन के साथ आ सकता है:

impl Mul<f64, f64> for Complex { 
    fn mul(self, rhs: f64) -> f64 { 
     self.x * rhs 
    } 
} 

जब हम अब एक f64 द्वारा एक Complex गुणा, यह जो कार्यान्वयन बुलाया जाना चाहिए, और अतिरिक्त प्रकार की जानकारी फोन करने वाले द्वारा आपूर्ति किए जाने की जरूरत है अस्पष्ट है। Output एक संबंधित प्रकार बनाकर, यह अस्वीकृत है।निम्नलिखित कोड परस्पर विरोधी कार्यान्वयन के लिए एक संकलक त्रुटि फेंकता है:

impl std::ops::Mul<f64> for Complex { 
    type Output = Complex; 
    fn mul(self, rhs: f64) -> Complex { 
     Complex::new(self.x * rhs, self.y * rhs) 
    } 
} 

impl std::ops::Mul<f64> for Complex { 
    type Output = f64; 
    fn mul(self, rhs: f64) -> Complex { 
     self.x * rhs 
    } 
} 

Full example

Answer 2

यह है कि आउटपुट प्रकार निर्दिष्ट करने के लिए कौन है। आम तौर पर जब आप दो प्रकार गुणा करते हैं, तो f64f64 पर कहें, यह स्पष्ट है कि परिणाम का प्रकार क्या होना चाहिए: f64। कॉलर के परिणामके परिणाम प्रकार के लिए पूछने के लिए यह समझ में नहीं आता है - इसलिए यह वास्तव में इनपुट के रूप में समझ में नहीं आता है।

मैं कुछ मामलों की कल्पना कर सकता हूं जहां आप विकल्प अलग-अलग आउटपुट चाहते हैं, लेकिन वे थोड़ा सा आला हैं (u32 * u32 पूर्ण u64 परिणाम लौटाते हैं?); इसके अलावा यदि एक से अधिक विकल्प थे, तो आप यह निर्दिष्ट कैसे करते हैं कि आप कौन सा चाहते हैं? जबकि आप Add<u32, u64>::add(a, b) लिख सकते हैं, तो यह a*b*c संदिग्ध सरल अभिव्यक्ति करेगा और टाइप अनुमान को अधिक कठिन बना देगा!