जंग में डेटा प्रकार से कैसे मिलान करें?

Question

मैं एक संरचना के एक सामान्य क्षेत्र के डेटाटाइप पर मिलान करने की कोशिश कर रहा हूं और तदनुसार प्रतिक्रिया करता हूं। मेरे सामान्य विचार इस तरह था (कोड संकलन नहीं करता है):

struct foo<T> { 
    zaz: String, 
    bar: T, 
} 

fn main() { 
    let x = foo::<String> { 
     zaz: "Hello".to_string(), 
     bar: "world".to_string(), 
    }; 
    let y = foo::<u32> { 
     zaz: "Hello".to_string(), 
     bar: 5, 
    }; 

    match x.bar { 
     String => println!("It's a string!"), 
     u32 => println!("It's a u32!"), 
     _ => println!("Something else"), 
    }; 

    println!("end of program!"); 
} 

rustc से त्रुटि संदेश:

error[E0001]: unreachable pattern 
    --> src/main.rs:18:9 
    | 
18 |   u32 => println!("It's a u32!"), 
    |   ^^^ this is an unreachable pattern 
    | 
note: this pattern matches any value 
    --> src/main.rs:17:9 
    | 
17 |   String => println!("It's a string!"), 
    |   ^^^^^^ 

error[E0001]: unreachable pattern 
    --> src/main.rs:19:9 
    | 
19 |   _ => println!("Something else"), 
    |  ^this is an unreachable pattern 
    | 
note: this pattern matches any value 
    --> src/main.rs:17:9 
    | 
17 |   String => println!("It's a string!"), 
    |   ^^^^^^ 

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

Answer 1

मुहावरेदार समाधान

एक विशेषता है जो foo में पैरामीटर T रोकें बनाएँ, इस विशेषता का एक संबद्ध समारोह के रूप में किसी भी विशिष्ट व्यवहार को लागू।

उदाहरण:

trait PrintMe { 
    fn print_me(&self); 
} 

impl PrintMe for String { 
    fn print_me(&self) { println!("I am a string"); } 
} 

struct Foo<T: PrintMe> { 
    zaz: String, 
    bar: T 
} 

fn main() { 
    // ... 
    x.bar.print_me(); 
} 

यह वह जगह है सैद्धांतिक सामान्य प्रोग्रामिंग, जहां वास्तव में संभव सामान्य मापदंडों के व्यवहार के अंतर का ऐलान करते हैं ताकि है वहाँ कोई आश्चर्य की बात।

---

सटीक समाधान

जंग कर सकते हैं वास्तव में क्वेरी प्रकार: प्रत्येक प्रकार के एक अनूठा TypeId जुड़े है, और आप if चेक की एक श्रृंखला के साथ TypeId पर मिलान कर सकते हैं। यह गुंजाइश है।

fn print_me<T>(x: &Foo<T>) { 
    if TypeId::of::<T>() == TypeId::of::<String>() { 
     println!("I am a string"); 
    } else // ... 
} 

लेकिन कृपया ... कि :)