Как реализовать PartialEq для вектора для моих собственных структур?

Question

У меня есть следующее определение:

pub struct List<T> { 
    memory: Vec<T>, 
} 

я хотел бы получить эквивалент #[derive(PartialEq)] для такого типа, как описывают в How can I implement PartialEq?

Я использую выражение матч, как:

impl<T: PartialEq> PartialEq for List<T> { 
    fn eq(&self, other: &List<T>) -> bool { 
     self.memory == other.memory  
    } 
} 
impl<T: fmt::Debug> fmt::Debug for List<T> where T:Display { 
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 
     try!(write!(f, "[")); 
     for (count, v) in self.memory.iter().enumerate() { 
      if count != 0 { try!(write!(f, ", ")); } 
      try!(write!(f, "{}", v)); 
     } 
     write!(f, "]") 
    } 
} 
impl<T> List<T> { 
    pub fn new() -> Self { 
     List { 
      memory: Vec::new(), 
     } 
    } 
    // push() add to end of list 
    pub fn push(&mut self, value: T) { 
     self.memory.push(value); 
    } 
} 

Но компилятор дает мне следующие ошибки:

error: mismatched types [E0308]

if ! (* left_val == * right_val) {

note: in this expansion of assert_eq!

help: run rustc --explain E0308 to see a detailed explanation

note: expected type librusty_data_structures::List<u32>

note: found type [_; 4]

main.rs, которые производят ошибки компиляции

let mut listex: List<u32> = List::new(); 
listex.push(17); 
listex.push(18); 
listex.push(19); 
listex.push(20);    
assert_eq!(listex, [17, 18, 19, 20]); 

Я не понимаю, почему это важно. Почему он даже смотрит на этот тип?

Answer 1

listex и [17, 18, 19, 20] имеют разные типы (List<u32> и [_; 4]), поэтому вы не можете проверить их равенство. Вам нужно изменить тип одного из аргументов assert_eq!(), чтобы типы соответствовали. Простейший вариант будет ссылаться listex «s memory:

assert_eq!(&listex.memory[0..4], [17, 18, 19, 20]);

Или вы можете конвертировать [17, 18, 19, 20] в List<u32>, так что PartialEq реализации для List<T> может быть введена в действие.

Если вы сравните listex с другим List<32>, ваша PartialEq реализации позволит проверки на равенство (хотя вы нуждаетесь в List<T> для получения Debug для того, чтобы сделать выполнять assert_eq!() на них).

Edit: в ответ на свой вопрос «Почему это даже не смотря на этого типа?», Обратите внимание, что в вашей реализации PartialEq:

fn eq(&self, other: &List<T>)

Вы указываете, что только eq работы для двух аргументов типа &List<T> (&self указывает на List<T>).

Answer 2

Вот решение, следуя cuviper response на ржавчину Programming Language Forum

impl<T, U> PartialEq<U> for List<T> 
    where Vec<T>: PartialEq<U> 
{ 
    fn eq(&self, other: &U) -> bool { 
     self.memory.eq(other) 
    } 
} 

Для теста:

let mut listex: List<u32> = List::new(); 

listex.push(17); 
listex.push(18); 
listex.push(19); 
listex.push(20);    

println!("{}", listex == [17, 18, 19, 20]);