विधि से वापसी का निशान

Question

मैं एक ऐसा फ़ंक्शन बनाने की कोशिश कर रहा हूं जो एक विशेषता देता है, इस मामले में शेडर Shader (जो नीचे दिए गए कोड उदाहरण में ShaderTrait के रूप में उपयोग किया जाता है)।

त्रुटि: हालांकि मैं निम्न त्रुटि प्राप्त विशेषता core::marker::Sized प्रकार opal_core::shader::Shader

यह समझ में आता है के रूप में संकलक विशेषता के आकार पता नहीं है के लिए लागू नहीं है, लेकिन कहीं मैं पा सकते हैं इसे ठीक करने का अनुशंसित तरीका। & के साथ एक संदर्भ वापस पास करने से काम नहीं करेगा (afaik), क्योंकि संदर्भ इसके निर्माता के जीवनकाल से अधिक होगा। शायद मुझे Box<T> का उपयोग करने की आवश्यकता है?

impl GraphicsContextTrait for GraphicsContext { 

    /// Creates a shader object 
    fn create_shader(&self, stage: Stage, source: &str) -> ShaderTrait { 
     let id; 

     unsafe { 
      id = self.functions.CreateShader(shader_stage_to_int(&stage)); 
     } 

     let shader = Shader { 
      id: id, 
      stage: stage, 
      context: self 
     }; 

     shader 
    } 
} 

धन्यवाद यदि आप मदद कर सकते हैं:

यहाँ कोड उदाहरण है।

Answer 1

हां। फिलहाल, आपको या तो &T या Box<T> वापस करने की आवश्यकता है, और आप इस उदाहरण में सही हैं, &T असंभव है।

"सार वापसी प्रकार" T संभव लौटने बनाना होगा: https://github.com/rust-lang/rfcs/issues/518

Answer 2

यह ठीक आप जो खोज रहे हैं नहीं हो सकता है, लेकिन मुझे लगता है कि आप जेनरिक और स्थिर प्रेषण उपयोग कर सकते हैं (मुझे पता नहीं है, तो वे हैं सही शब्द, मैंने अभी किसी और को इसका उपयोग करने के लिए देखा) इस तरह कुछ बनाने के लिए।

यह बिल्कुल "एक विशेषता के रूप में लौटने" नहीं है, लेकिन यह कार्यों को सामान्य रूप से लक्षणों का उपयोग करने दे रहा है। वाक्यविन्यास थोड़ा अस्पष्ट है, इमो, इसलिए इसे याद करना आसान है।

Iterator विशेषता लौटने के बारे में यहां एक संबंधित पोस्ट है। यह बदसूरत हो जाता है। https://stackoverflow.com/a/30641982/97964

खेल का मैदान में: http://is.gd/ELgzen

struct MyThing { 
    name: String 
} 

trait MyTrait { 
    fn get_name(&self) -> String; 
} 

impl MyTrait for MyThing { 
    fn get_name(&self) -> String { 
     self.name.clone() 
    } 
} 

// This is where the magic happens 
fn as_trait<T: MyTrait>(t: T) -> T { 
    return t 
} 

fn main() { 
    let t = MyThing { name: "James".to_string() }; 
    let new_t = as_trait(t); 

    println!("Hello, world! {}", new_t.get_name()); 
} 

Answer 3

मुझे लगता है कि आप क्या खोज रहा था। कम से कम, जब मैं इसे खोज रहा था तब मैं यहां पहुंचा।

एक साधारण जंग में लागू कारखाना:

pub trait Command { 
    fn execute(&self) -> String; 
} 

struct AddCmd; 
struct DeleteCmd; 

impl Command for AddCmd { 
    fn execute(&self) -> String { "It add".into() } 
} 

impl Command for DeleteCmd { 
    fn execute(&self) -> String { "It delete".into() } 
} 

fn command(s: &str) -> Option<Box<Command+'static>> { 
    match s { 
     "add" => Some(Box::new(AddCmd)), 
     "delete" => Some(Box::new(DeleteCmd)), 
     _ => None 
    } 
} 

fn main() { 
    let a = command("add").unwrap(); 
    let d = command("delete").unwrap(); 
    println!("{}", a.execute()); 
    println!("{}", d.execute()); 
} 

https://gist.github.com/cristianoliveira/722204361927761ae69c150fde040059