जेनेरिक प्रकार टी

Question

के लिए अधिकतम स्वीकार्य मान ढूँढना मैं एक मर्ज सॉर्ट को कार्यान्वित कर रहा हूं जो T प्रकार की सरणी को सॉर्ट करेगा। मेरे merge विधि में, एल्गोरिदम बाएं और दाएं सूची के अंतिम तत्व के लिए कॉल करता है सकारात्मक अनंतता। मैं दिए गए डेटा प्रकार को अधिकतम मूल्य कैसे प्राप्त कर सकता हूं?

fn merge<T: PartialOrd + Copy + std::fmt::Debug>(p: usize, q: usize, r: usize, array: &mut Vec<T>) { 
    let left_size: usize = q - p; 
    let right_size: usize = r - q; 

    let mut left: Vec<T> = Vec::new(); 
    let mut right: Vec<T> = Vec::new(); 

    for i in 0..left_size { 
     left.push(array[p + i]); 
    } 

    for i in 0..right_size { 
     right.push(array[q + i]); 
    } 

    left.push(T::max_value()); //where I would put the max value 
    right.push(T::max_value()); //where I would put the max value 

    let mut i: usize = 0; 
    let mut j: usize = 0; 

    for k in p..r { 
     if left[i] <= right[j] { 
      array[k] = left[i]; 
      i += 1; 
     } else { 
      array[k] = right[j]; 
      j += 1; 
     } 
    } 
} 

Answer 1

जहां तक ​​मुझे पता है, इस समय मानक पुस्तकालय के साथ ऐसा करने का कोई तरीका नहीं है। इसे हल करने का एक तरीका आपकी खुद की विशेषता बनायेगा, merge पर एक और विशेषता जोड़ें और आप जिस प्रकार की अपेक्षा कर रहे हैं उसके लिए अपनी विशेषता लागू करें।

u32 के लिए विशिष्ट विशेषता कार्यान्वयन std::u32::MAX और अन्य प्रकार के लिए वापस लौटाएगा।

यहां एक discussion from earlier this year है।

oli_obk - ker pointed out नीचे num क्रेट में पहले से ही ऐसी विशेषता है: Bounded।

Answer 2

एक सामान्य ऊपरी बाध्य आप भी एक enum में टाइप लपेट सकता है के लिए:

#[derive(Clone, Copy, PartialEq, PartialOrd, Debug)] 
enum UpperBounded<T> { 
    Value(T), 
    Max, 
} 

derived order is documentedValue(_)Max से पहले सॉर्ट करने के लिए।

UpperBounded<T> का उपयोग left और right वैक्टर के लिए किया जा सकता है।