Rust中如何让Nibbler同时支持&u8与&mut u8迭代器

现有实现问题 #

原始只读版本的Nibbler仅支持迭代项为&u8的迭代器，核心逻辑如下：

pub enum Nibble<'a> {
    MSB(&'a u8),
    LSB(&'a u8),
}

impl Nibble<'_> {
    pub fn from_u8(input: &u8) -> (Nibble, Nibble) {
        let msb = Nibble::MSB(input);
        let lsb = Nibble::LSB(input);
        (msb, lsb)
    }

    pub fn get(&self) -> u8 {
        match self {
            Nibble::MSB(r) => (**r & 0b11110000) >> 4,
            Nibble::LSB(r) => **r & 0b00001111,
        }
    }
}

pub struct Nibbler<'a, T> {
    rest: Option<Nibble<'a>>,
    inner: T,
}

impl<T> Nibbler<'_, T> {
    pub fn new(inner: T) -> Self {
        Nibbler { inner, rest: None }
    }
}

impl<'a, T: Iterator<Item = &'a u8>> Iterator for Nibbler<'a, T> {
    type Item = Nibble<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        self.rest.take().or_else(|| {
            self.inner.next().map(|byte| {
                let (msb, lsb) = Nibble::from_u8(byte);
                self.rest = Some(msb);
                lsb
            })
        })
    }
}

尝试直接使用Borrow<u8>作为泛型约束时会触发E0515生命周期错误：

error[E0515]: cannot return value referencing function parameter `byte`
  --> src/utils/nibbler2.rs:42:17
   |
40 |                 let (msb, lsb) = Nibble::from_u8(byte.borrow());
   |                                                  ------------- `byte` is borrowed here
41 |                 self.rest = Some(msb);
42 |                 lsb
   |                 ^^^ returns a value referencing data owned by the current function

错误根因 #

Borrow<u8>/AsRef<u8>的实现范围过宽，除了&u8、&mut u8这类引用类型外，还覆盖了u8值类型。当迭代器返回u8值时，byte.borrow()得到的引用生命周期仅绑定到next方法内的局部变量byte，函数返回后局部变量被销毁，返回的Nibble会持有悬垂引用，被编译器拦截。

修复方案 #

核心思路是收窄泛型约束范围，仅为可以产出长生命周期&u8的引用类型实现转换逻辑，避免匹配到值类型。利用Rust可变引用可自动降级为只读引用的特性，通过自定义轻量trait统一两类引用的转换行为：

1. 首先定义仅针对u8引用的转换trait，明确返回引用的生命周期与原始引用一致

trait AsByteRef<'a> {
    fn as_byte_ref(&self) -> &'a u8;
}

// 为&u8实现
impl<'a> AsByteRef<'a> for &'a u8 {
    fn as_byte_ref(&self) -> &'a u8 {
        *self
    }
}

// 为&mut u8实现，自动降级为只读引用
impl<'a> AsByteRef<'a> for &'a mut u8 {
    fn as_byte_ref(&self) -> &'a u8 {
        *self
    }
}

2. 修改Nibbler的迭代器实现，将迭代项约束替换为自定义的AsByteRef<'a>

impl<'a, T, I> Iterator for Nibbler<'a, T>
where
    T: Iterator<Item = I>,
    I: AsByteRef<'a>,
{
    type Item = Nibble<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        self.rest.take().or_else(|| {
            self.inner.next().map(|byte| {
                let byte_ref = byte.as_byte_ref();
                let (msb, lsb) = Nibble::from_u8(byte_ref);
                self.rest = Some(msb);
                lsb
            })
        })
    }
}

验证 #

修改后的实现可以同时兼容两类迭代器，且不会引入生命周期问题：

fn main() {
    // 适配&u8迭代器
    let read_bytes = vec![0x12, 0x34];
    let read_nibbles = Nibbler::new(read_bytes.iter())
        .map(|n| n.get())
        .collect::<Vec<_>>();
    assert_eq!(read_nibbles, vec![0x1, 0x2, 0x3, 0x4]);

    // 适配&mut u8迭代器
    let mut mut_bytes = vec![0xAB, 0xCD];
    let mut_nibbles = Nibbler::new(mut_bytes.iter_mut())
        .map(|n| n.get())
        .collect::<Vec<_>>();
    assert_eq!(mut_nibbles, vec![0xA, 0xB, 0xC, 0xD]);
}

该实现不需要修改原有Nibble结构和核心位运算逻辑，后续如果需要扩展可变半字节写入能力，只需要在trait中增加as_byte_mut方法，为&mut u8实现对应转换即可。

内容的提问来源于stack exchange，提问作者Mathijs Kwik