एक सामान्य प्रकार कास्टिंग

Question

मेरे पास जंग में जेनिक्स के बारे में एक नया सवाल है (संस्करण 1.0)।

मान लें कि मैं विभाजन करने के लिए एक सामान्य कार्य लिखता हूं। ऐसे फ़ंक्शन की उपयोगिता को कभी भी ध्यान न दें; यह सवाल सरल रखने के लिए यह एक आसान काम है।

fn divide<T: std::ops::Div>(a: T, b: T) -> T { 
    a/b 
} 

fn main() { 
    println!("{}", divide(42, 18)) 
} 

यह प्रोग्राम संकलित करने में विफल रहता है।

src/main.rs:2:5: 2:10 error: mismatched types: 
expected `T`, 
    found `<T as core::ops::Div>::Output` 
(expected type parameter, 
    found associated type) [E0308] 
src/main.rs:2  a/b 
        ^~~~~ 

मैं समझता हूँ कि संकलक त्रुटि कह रहा है कि विभाजन आपरेशन के परिणाम टाइप Output, नहीं T है, और मैं standard library documentation में Output प्रकार देखते हैं।

मैं Output से T से कैसे परिवर्तित करूं? मैं कास्ट करने के लिए as का उपयोग करने का प्रयास करता हूं।

fn divide<T: std::ops::Div>(a: T, b: T) -> T { 
    (a/b) as T 
} 

fn main() { 
    println!("{}", divide(42, 18)) 
} 

यह एक अलग संकलक त्रुटि का कारण बनता है।

src/main.rs:2:5: 2:17 error: non-scalar cast: `<T as core::ops::Div>::Output` as `T` 
src/main.rs:2  (a/b) as T 
        ^~~~~~~~~~~~ 

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

अंदर डाली नहीं कर सकते जब आप में हैं के बारे में अधिक विवरण जोड़ने के लिए

fn divide<T: std::ops::Div>(a: T, b: T) -> T::Output { 
    a/b 
} 

संपादित करें:

Answer 1

आप बस समारोह की वापसी प्रकार के रूप में T::Output निर्दिष्ट करना आपका सामान्य फ़ंक्शन विभाजित करता है, संकलक अभी तक नहीं जानता है कि आप T से T::Output पर जा सकते हैं, इसलिए कलाकार अमान्य है। वे सामान्य प्रकार हैं, वे कुछ भी हो सकते हैं, कैसे संकलक जानता है कि आप T से T::Output पर जा सकते हैं?

a/bT::Output के प्रकार का उत्पादन करता है, इसलिए ऊपर दिए गए समाधान में कास्ट नहीं किया गया है, T::Output बस सही प्रकार है। सबसे अधिक (मुझे लगता है कि) सामान्य कार्यान्वयन है जब आप जानते हैं कि टी के लिए T::Output से डाली संभव है एक और संभव समाधान एसटीडी का उपयोग कर जोड़ने के लिए

संपादित :: परिवर्तित :: से

। T::Output के लिए From लागू करने के लिए आप T बाध्य कर सकते हैं। यह एक पूर्ण उदाहरण है:

use std::ops::Div; 
use std::convert::From; 

fn divide<T: Div>(a: T, b: T) -> T 
    where T: From<<T as Div>::Output> 
{ 
    T::from(a/b) 
} 

#[derive(Debug)] 
struct Bip(u32); 

impl Div for Bip { 
    type Output = f32; 

    fn div(self, rhs: Bip) -> f32 { 
     (self.0/rhs.0) as f32 
    } 
} 

impl From<f32> for Bip { 
    fn from(value: f32) -> Self { 
     Bip(value as u32) 
    } 
} 

fn main() { 
    println!("{:?}", divide(12, 4)); 
    println!("{:?}", divide(Bip(12), Bip(4))); 
} 

Answer 2

एंड्रियास 'जवाब बताता है कि क्यों डाली असंभव है, और है कि जेनेरिक इस मुद्दे संभव हल के रूप में के रूप में कार्य कर रही है।

हालांकि, यह एकमात्र समाधान नहीं है। जंग एक सामान्य कार्य के संबंधित प्रकारों (Output यहां) को बाधित करने की क्षमता का भी समर्थन करता है।

एक वैकल्पिक होगा:

use std::ops::Div; 

fn divide<T>(a: T, b: T) -> T 
    where T: Div<Output = T> 
{ 
    a/b 
} 

<Output = T> बिट संकलक केवल स्वीकार करने के लिए इस प्रकार के TDiv के कार्यान्वयन एक OutputT के बराबर है, जिसके लिए काम करता है में निर्देश देता है। यह स्पष्ट रूप से अधिक प्रतिबंधित है, लेकिन यह सुनिश्चित करने की अनुमति देता है कि divide का परिणाम T है।