为什么我不能在数组声明中使用类型推断？

Question

我声明了一个自定义trait Animal的数组，以便在Rust中试验多态性，但是编译器似乎在第一个元素的子类型上进行类型推断:

fn main() {
    let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
    for single_animal in animals {
        single_animal.talk();
    }
}

trait Animal {
    fn talk(&self);
}

struct Cat;
struct Dog;
struct Lion;

impl Animal for Cat {
    fn talk(&self) { 
        println!("Je miaule !");
    }
}

impl Animal for Dog {
    fn talk(&self) { 
        println!("J'aboie !");
    }
}

impl Animal for Lion {
    fn talk(&self) {
        println!("Je rugit !");
    }
}

编译器抱怨第一个元素是< code>Cat而不是其他元素:

error: mismatched types [--explain E0308]
 --> src/main.rs:3:25
  |>
3 |>     let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>                         ^^^ expected struct `Cat`, found struct `Dog`
note: expected type `Cat`
note:    found type `Dog`

error: mismatched types [--explain E0308]
 --> src/main.rs:3:35
  |>
3 |>     let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>                                   ^^^^ expected struct `Cat`, found struct `Lion`
note: expected type `Cat`
note:    found type `Lion`

error: mismatched types [--explain E0308]
 --> src/main.rs:3:41
  |>
3 |>     let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>                                         ^^^ expected struct `Cat`, found struct `Dog`
note: expected type `Cat`
note:    found type `Dog`

error: mismatched types [--explain E0308]
 --> src/main.rs:3:46
  |>
3 |>     let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>                                              ^^^^ expected struct `Cat`, found struct `Lion`
note: expected type `Cat`
note:    found type `Lion`

error: the trait bound `[Cat; 6]: std::iter::Iterator` is not satisfied [--explain E0277]
 --> src/main.rs:4:5
  |>
4 |>     for single_animal in animals {
  |>     ^
note: `[Cat; 6]` is not an iterator; maybe try calling `.iter()` or a similar method
note: required by `std::iter::IntoIterator::into_iter`

向数组中添加Animal类型也不能解决问题。因为这一次我得到了更多的错误：

error: mismatched types [--explain E0308]
 --> src/main.rs:3:27
  |>
3 |>     let animals: Animal = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected trait Animal, found array of 6 elements
note: expected type `Animal`
note:    found type `[Cat; 6]`

error: the trait bound `Animal: std::marker::Sized` is not satisfied [--explain E0277]
 --> src/main.rs:3:9
  |>
3 |>     let animals: Animal = [Cat, Dog, Cat, Lion, Dog, Lion];
  |>         ^^^^^^^
note: `Animal` does not have a constant size known at compile-time
note: all local variables must have a statically known size

error: the trait bound `Animal: std::marker::Sized` is not satisfied [--explain E0277]
 --> src/main.rs:4:5
  |>
4 |>     for single_animal in animals {
  |>     ^
note: `Animal` does not have a constant size known at compile-time
note: required by `std::iter::IntoIterator::into_iter`

error: the trait bound `Animal: std::iter::Iterator` is not satisfied [--explain E0277]
 --> src/main.rs:4:5
  |>
4 |>     for single_animal in animals {
  |>     ^
note: `Animal` is not an iterator; maybe try calling `.iter()` or a similar method
note: required by `std::iter::IntoIterator::into_iter`

Answer 1

这是因为猫，狗和狮子都是不同的类型，你只能在数组中有一个。

你可以像卢卡斯建议的那样使用trait对象，但你所追求的可能更容易实现（trait对象不是我推荐给Rust初学者的东西），有一个常见的动物枚举：

use self::Animal::*;

fn main() {
    let animals = [Cat, Dog, Cat, Lion, Dog, Lion];
    for single_animal in animals.iter() {
        single_animal.talk();
    }
}

trait AnimalSkills {
    fn talk(&self);
}

enum Animal {
    Cat,
    Dog,
    Lion
}

impl AnimalSkills for Animal {
    fn talk(&self) {
        match *self {
            Cat => println!("Je miaule !"),
            Dog => println!("J'aboie !"),
            Lion => println!("Je rugit !")
        }
    }
}

另请注意，您需要调用. iter（）才能迭代数组。

Answer 2

Rust数组是均匀的，这意味着其中的每个元素都具有相同的类型。因此，不能将数组与＜code＞Dog＜/code＞s和＜code＞Cat＜/code＞s组合。但在您的例子中，您可以拥有一个充满所谓“trait对象”的数组

你必须明确地告诉编译器你想要一个包含trait对象的数组。编译器根据初始值设定项中的第一个元素推断数组的类型，因此让我们显式转换该元素：

let animals = [&Cat as &Animal, &Dog, &Cat, &Lion, &Dog, &Lion];

请注意，我们还添加了一个< code >