"Expected type parameter" Fehler im Konstruktor einer generischen Struktur

Question

Ich versuche, Kolben Texturen in einer Struktur zu speichern.

struct TextureFactory<R> where R: gfx::Resources { 
    block_textures: Vec<Rc<Texture<R>>>, 
} 

impl<R> TextureFactory<R> where R: gfx::Resources { 
    fn new(window: PistonWindow) -> Self { 
     let texture = Rc::new(gfx_texture::Texture::from_path(
      &mut *window.factory.borrow_mut(), 
      "assets/element_red_square.png", 
      Flip::None, &TextureSettings::new() 
     ).unwrap()); 
     let block_textures = Vec::new(); 
     block_textures.push(texture); 

     TextureFactory { 
      block_textures: block_textures, 
     } 
    } 
} 

Dies lässt sich nicht kompilieren:

src/main.rs:37:9: 39:10 error: mismatched types: 
expected `TextureFactory<R>`, 
    found `TextureFactory<gfx_device_gl::Resources>` 
(expected type parameter, 
    found enum `gfx_device_gl::Resources`) 

gfx_device_gl::Resourcesimplements gfx::Resources obwohl (ich glaube, es ist nur die gerätespezifische Implementierung.) Ich interessiere mich nicht wirklich, welche Art dies ist, aber ich brauche, dies zu wissen dass ich es in der Struktur speichern kann.

Ich habe einen compilable repo on Github.

(ich vermute Rust generics/traits: "expected 'Foo<B>', found 'Foo<Foo2>'" die gleiche Frage, aber ich kann nicht herausfinden, wie es zu meinem Problem anzuwenden.)

Answer 1

Hier ist eine Reproduktion Ihrer Fehler:

struct Foo<T> { 
    val: T, 
} 

impl<T> Foo<T> { 
    fn new() -> Self { 
     Foo { val: true } 
    } 
} 

fn main() { 

} 

Das Problem entsteht, weil du versucht hast, den Compiler zu belügen. Dieser Code:

impl<T> Foo<T> { 
    fn new() -> Self {} 
} 

sagt „Denn alles, was T der Anrufer wählt, werde ich eine Foo mit dieser Art schaffen“. Dann ist Ihre tatsächliche Umsetzung nimmt eine konkreten - im Beispiel ein bool. Es gibt keine Garantie, dass T ein bool ist. Beachten Sie, dass Ihre new-Funktion nicht einmal einen Parameter des Typs T akzeptiert, der sehr verdächtig ist, da der Anrufer den Betontyp 99% der Zeit wählt.

Die richtige Art zu sagen, diese

impl Foo<bool> { 
    fn new() -> Self { 
     Foo { val: true } 
    } 
} 

wäre Obwohl Sie wahrscheinlich einen bestimmten Namen als new auswählen möchten, wie es aussieht, als wenn Sie Ihre Struktur generic versuchen zu machen. Vermutlich würde es andere Konstruktoren mit verschiedenen Typen geben.

Für Ihre genauen Code, werden Sie wahrscheinlich wollen etwas wie

impl TextureFactory<gfx_device_gl::Resources> { ... } 

Natürlich eine andere mögliche Lösung wäre, die generischen Typparameter aus Ihrer Struktur zu entfernen. Wenn Sie es nur mit einem gfx_device_gl::Resources konstruieren, dann gibt es keinen Grund, es generisch zu machen.