方法 `fold` 存在以供参考 `&[T]`，但它的特征边界不满足，我不理解有问题的给定边界

Question

所以我正在构建一个 chip-8 CPU 模拟器，为了更容易地将数据复制到内存中，我创建了以下两种方法：

pub struct CPU {
    // ... other unrelated fields
    pub memory: [u8; 0x1000],
}

impl CPU {
    pub fn raw_copy_to_mem(&mut self, loc: usize, data: &[u8]) {
        data.chunks(2).fold(loc, |loc, bytes| {
            self.raw_add_to_mem(loc, *bytes.first().unwrap(), *bytes.last().unwrap())
        });
    }

    pub fn raw_add_to_mem(&mut self, loc: usize, high: u8, low: u8) -> usize {
        self.memory[loc] = high; self.memory[loc + 1] = low;
        loc + 2
    }
}

现在这适用于这个例子：

fn make_cpu() -> processor::CPU {

   processor::CPU {
        // ... other unrelated fields
        memory: [0; 0x1000],
    }
}
#[test]
fn test_raw_memory_copy() {
    let mut cpu = make_cpu();

    let add_twice: [u8; 6] = [
        0x80, 0x14,
        0x80, 0x14,
        0x00, 0xEE,
    ];

    cpu.raw_copy_to_mem(0x100 , &add_twice);

    assert_eq!(cpu.memory[0x100..0x106], add_twice);

}

现在为了使操作代码更容易，我有以下结构和函数：

#[derive(Debug, Clone, Copy)]
pub struct OpCode(u8, u8);

impl OpCode {
    pub fn high_byte(&self) -> u8 {
        self.0
    }

    pub fn low_byte(&self) -> u8 {
        self.1
    }
}

impl From<OpCode> for u16 {
    fn from(c: OpCode) -> Self {
        (c.0 as u16) << 8 | c.1 as u16
    }
}

impl From<&OpCode> for u16 {
    fn from(c: &OpCode) -> u16 {
        c.into()
    }
}

impl OpCode {
    pub fn add(h: u8, l: u8) -> Self {
        Self (0x8 << 4 | h, (l << 4) | 4)
    }
}

下面的 CPU 函数也很好用：

impl CPU {
    pub fn add_to_mem(&mut self, loc: usize, oc: &OpCode) -> usize {
        self.memory[loc] = oc.high_byte(); self.memory[loc + 1] = oc.low_byte();
        loc + 2
    }
}

当我尝试为 OpCode 结构添加 copy_to_mem() 函数时出现问题：

impl CPU {
    pub fn copy_to_mem(&mut self, loc: usize, data: &[OpCode]) {
        data.fold(loc, |loc, opcode| {
            self.add_to_mem(loc, opcode)
        });
    }
}

我收到以下我只是模糊理解的错误：

error[E0599]: the method `fold` exists for reference `&[OpCode]`, but its trait bounds were not satisfied
  --> src/processor.rs:21:14
   |
21 |         data.fold(loc, |loc, bytes| {
   |              ^^^^ method cannot be called on `&[OpCode]` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `&[OpCode]: Iterator`
           which is required by `&mut &[OpCode]: Iterator`
           `[OpCode]: Iterator`
           which is required by `&mut [OpCode]: Iterator`

我知道它是说虽然有一个 fold() 函数并且它不能调用它，因为一些特征边界不满足所以它不能调用它但它没有说明我可以理解这些界限是什么。

那么，有人可以解释发生了什么，以及如何解决吗？

Answer 1

错误消息具有误导性：问题是您试图将切片用作迭代器，但事实并非如此。要获取切片的迭代器，请将其称为 iter() method (or iter_mut() 可变迭代器）。

pub fn copy_to_mem(&mut self, loc: usize, data: &[OpCode]) {
    data.iter().fold(loc, |loc, bytes| {
        self.add_to_mem(loc, bytes.high_byte())
    });
}

请注意，它仍然会出错：

error[E0308]: mismatched types
  --> src/lib.rs:60:34
   |
60 |             self.add_to_mem(loc, bytes.high_byte())
   |                                  ^^^^^^^^^^^^^^^^^ expected `&OpCode`, found `u8`

因为 add_to_mem 期望 &OpCode 但 bytes 确实是 &OpCode bytes.high_byte() 是 u8.

方法 `fold` 存在以供参考 `&[T]`，但它的特征边界不满足，我不理解有问题的给定边界

the method `fold` exists for reference `&[T]`, but its trait bounds were not satisfied, I don't understand the given bounds in question

rust

traits

type-bounds