Wie Trait Implementoren

Question

Ich habe eine Eigenschaft, die von einigen Strukturen implementiert wird. Ich möchte ein Mustervergleich schreiben, wo ich jeden denkbaren Fall umgehen kann:

trait Base {} 

struct Foo { x: uint } 
struct Bar { y: uint } 

impl Base for Foo {} 
impl Base for Bar {} 

fn test(v: bool) -> Box<Base + 'static> { 
    // Let's pretend there's real logic that determines what to return. 
    if v { 
     box Foo { x: 5 } 
    } else { 
     box Bar { y: 10 } 
    } 
} 

fn main() { 
    let f: Box<Base> = test(true); 

    // Now that we have a `Box<Base>` (`*f` makes it a `Base`), 
    // let's handle different cases: 
    match *f { 
     Foo { x } => println!("it was Foo: {}!", x), 
     Bar { y } => println!("it was Bar: {}!", y), 
    } 
} 

(versuchen Sie es online: http://is.gd/YuBkPF)

Ich bekomme diese Kompilierungsfehler:

mismatched types: expected Base , found a structure pattern

Answer 1

Sie können t. Eigenschaften unterstützen keine Downcasting - Rust ist keine Vererbung/Subtyping-basierte Sprache, und es gibt Ihnen eine weitere Reihe von Abstraktionen. Darüber hinaus ist das, was Sie tun wollen, nicht stichhaltig - Eigenschaften sind offen (jeder kann sie für irgendetwas implementieren), also selbst wenn in Ihrem Fall match *f alle möglichen Fälle abdeckt, kann der Compiler im Allgemeinen das nicht wissen.

Sie haben hier zwei Möglichkeiten. Wenn Sie die Menge der Strukturen kennen, die Ihr Merkmal im Voraus implementieren, benutzen Sie einfach enum, es ist ein perfektes Werkzeug dafür. Sie ermöglichen es, statisch auf einer geschlossenen Reihe von Varianten zum Spiel:

enum FooBar { 
    Foo(uint), 
    Bar(uint) 
} 

fn test(v: bool) -> FooBar { 
    if v { 
     Foo(5) 
    } else { 
     Bar(10) 
    } 
} 

fn main() { 
    let f: FooBar = test(true); 

    // Now that we have a `Box<Base>` (`*f` makes it a `Base`), 
    // let's handle different cases: 
    match f { 
     Foo(x) => println!("it was Foo: {}!", x), 
     Bar(y) => println!("it was Bar: {}!", y), 
    } 
} 

(versuchen Sie es here)

Dies ist bei weitem der einfachste Weg, und es sollte immer bevorzugt werden. Eine andere Möglichkeit ist es, Any Merkmal zu verwenden. Es ist eine Einrichtung für typsichere Downcasting von Zug Objekte regelmäßig Typen:

use std::any::{Any, AnyRefExt}; 

struct Foo { x: uint } 
struct Bar { y: uint } 

fn test(v: bool) -> Box<Any + 'static> { // ' 
    if v { 
     box Foo { x: 5 } 
    } else { 
     box Bar { y: 10 } 
    } 
} 

fn main() { 
    let f: Box<Any> = test(true); 

    match f.downcast_ref::<Foo>() { 
     Some(&Foo { x }) => println!("it was Foo: {}!", x), 
     None => match f.downcast_ref::<Bar>() { 
      Some(&Bar { y }) => println!("it was Bar: {}!", y), 
      None => unreachable!() 
     } 
    } 

// it will be nicer when `if let` lands 
// if let Some(&Foo { x }) = f.downcast_ref::<Foo>() { 
//  println!("it was Foo: {}!", x); 
// } else if let Some(&Bar { y }) = f.downcast_ref::<Bar>() { 
//  println!("it was Bar: {}!", y); 
// } else { unreachable!() } 
} 

(versuchen Sie es here)

Im Idealfall sollte es möglich sein, so etwas zu schreiben:

trait Base : Any {} 

impl Base for Foo {} 
impl Base for Bar {} 

und dann Base im Code verwenden, aber es kann jetzt nicht ausgeführt werden, da die Merkmalvererbung nicht mit Merkmalsobjekten funktioniert (z. B. ist es unmöglich, von Box<Base> zu Base<Any> zu gehen).

Answer 2

Sie können meine match_cast Kiste verwenden:

match_cast!(any { 
    val as Option<u8> => { 
     format!("Option<u8> = {:?}", val) 
    }, 
    val as String => { 
     format!("String = {:?}", val) 
    }, 
    val as &'static str => { 
     format!("&'static str = {:?}", val) 
    }, 
}); 

match_down!(any { 
    Bar { x } => { x }, 
    Foo { x } => { x }, 
});