Сравните массивы определенной длины

Question

Примечание редактора: этот вопрос был задан до Rust 1.0 и использует синтаксис, который больше не действителен. Кроме того, конкретная проблема в этом вопросе больше не возникает в Rust 1.0.

Существует структура, которая содержит единственное поле - массив байтов фиксированной ширины. Казалось бы, что реализация черт из std::cmp ибо это было бы просто, но получение не работает:

#[deriving(Eq)]
pub struct ID {
    bytes: [u8, ..::constants::ID_SIZE]
}

src/id.rs:3:5: 3:40 error: mismatched types: expected `&&[u8]` but found `&[u8, .. 20]` ([] storage differs: expected `&` but found `20`)
src/id.rs:3     bytes: [u8, ..::constants::ID_SIZE]
                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
note: in expansion of #[deriving]
src/id.rs:1:1: 2:4 note: expansion site

Документация предполагает, что уравнение реализовано для &[] а также ~[], не для фиксированной ширины массива. Ручное приведение к &[] тоже не работает:

impl Eq for ID {
    fn eq(&self, other: &ID) -> bool {
        (&self.bytes).eq(&other.bytes)
    }
}

src/id.rs:7:26: 7:38 error: mismatched types: expected `&&[u8, .. 20]` but found `&[u8, .. 20]` (expected &-ptr but found vector)
src/id.rs:7         (&self.bytes).eq(&other.bytes)
                                     ^~~~~~~~~~~~
src/id.rs:7:9: 7:39 error: failed to find an implementation of trait std::cmp::Eq for [u8, .. 20]
src/id.rs:7         (&self.bytes).eq(&other.bytes)
                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Эта строка в справочном руководстве по Rust может объяснить это:

Выражения, производящие векторы определенного размера, не могут быть оценены в контексте, ожидающем вектор неопределенного размера; необходимо скопировать векторное содержимое определенного размера в отдельный вектор неопределенного размера.

Мотивация неясна, но я думаю, это как-то связано с сохранением длины.

В любом случае, возможно ли сравнить два массива фиксированной длины, используя реализацию &[]без копирования?

Answer 1

Документация предполагает, что уравнение реализовано для &[] и ~[], а не для массива с фиксированной шириной.

Да, это потому, что [T,..2] отличается от типа [T,..3].

В любом случае, возможно ли сравнить два массива с фиксированной длиной, используя реализацию для &[], без копирования?

Без труда

impl Eq for ID {
    fn eq(&self, other: &ID) -> bool {
        self.bytes.iter().zip(other.bytes.iter()).all(|(a,b)| a == b) 
    }
}