泛型结构的构造函数中的“预期类型参数”错误

Question

我正在尝试将活塞纹理存储在结构中。

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,
        }
    }
}

这不编译：

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::Resources虽然实现了gfx::Resources （我认为这只是特定于设备的实现。）我实际上并不关心这是什么类型，但我需要知道以便我可以将它存储在结构中。

我在 Github 上做了一个可编译的 repo 。

（我怀疑Rust 泛型/特征：“预期的 'Foo<B>', found 'Foo<Foo2>'”是同一个问题，但我不知道如何将其应用于我的问题。）

Answer 1

这是您的错误的再现：

struct Foo<T> {
    val: T,
}

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

fn main() {}

问题出现是因为您试图对编译器撒谎。 这段代码：

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

说“对于调用者选择的任何T ，我都会创建一个具有该类型的Foo ”。 然后您的实际实现选择一个具体的类型——在示例中，一个bool 。 不能保证T是bool 。 请注意，您的new函数甚至不接受任何类型的参数T ，这是非常值得怀疑的，因为这就是调用者在 99% 的情况下选择具体类型的方式。

正确的说法是

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

尽管您可能想选择一个比new更具体的名称，但看起来好像您正在尝试使您的结构通用。 大概会有其他不同类型的构造函数。

对于您的确切代码，您可能想要类似的东西

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

另一种可能的解决方案是从结构中删除泛型类型参数。 如果你只用gfx_device_gl::Resources构造它，那么没有理由让它通用。

在其他情况下，您可能会尝试返回实现 trait 的类型。 为此，您可以使用装箱的 trait 对象：

impl Foo<Box<dyn std::fmt::Display>> {
    fn new() -> Self {
        Foo { val: Box::new(true) }
    }
}

将来，您还可以使用impl Trait （又名存在类型）：

#![feature(type_alias_impl_trait)]

struct Foo<T> {
    val: T,
}

type SomeConcreteButOpaqueType = impl std::fmt::Display;

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

也可以看看：

• 返回迭代器（或任何其他特征）的正确方法是什么？