Rust 实现结构体转元组后如何直接迭代Vec解构遍历

受Rust 孤儿规则和trait实现一致性要求约束，你没法直接让原生Vec<BoundPair>的iter()方法直接返回(&Bound, &Bound, i32)元组的迭代器：

• vec.iter()返回的是标准库实现的std::slice::Iter<'_, BoundPair>类型，其迭代Item被硬编码为&BoundPair
• 你不能为标准库的Iter类型重复实现Iterator trait（标准库已经为所有Iter<T>实现过默认迭代逻辑，重复实现会触发编译器的重叠实现报错）
• 你也没法覆盖&Vec<BoundPair>默认的IntoIterator实现（默认逻辑就是返回迭代&BoundPair的迭代器，重复实现会直接冲突）

不过你可以通过实现自定义trait、封装迭代逻辑的方式，非常接近你想要的无冗余转换的迭代效果，下面是几种常用的落地方案：

方案1：扩展trait封装通用转换逻辑（轻量，无需修改原有数据结构） #

你可以写一个扩展trait，给所有迭代&BoundPair的迭代器统一添加转换方法，不用每次手动写完整的map逻辑：

trait BoundPairTupleIter<'a> {
    fn into_tuple_iter(self) -> impl Iterator<Item = (&'a Bound, &'a Bound, i32)>;
}

impl<'a, I> BoundPairTupleIter<'a> for I
where
    I: Iterator<Item = &'a BoundPair>,
{
    fn into_tuple_iter(self) -> impl Iterator<Item = (&'a Bound, &'a Bound, i32)> {
        self.map(|item| item.into())
    }
}

使用的时候只需要在原来的迭代器后追加方法即可，比手写全量map要简洁很多：

let vec = vec![instance.clone(), instance.clone()];
for (a, b, c) in vec.iter().into_tuple_iter() {
    println!("tuple: {:.?}", (a, b, c));
}

方案2：封装自定义向量类型（可实现完全无需额外转换的迭代写法） #

如果你希望完全做到和你预期的无额外步骤的迭代写法，可以把Vec<BoundPair>封装成自己的结构体，自定义迭代逻辑：

// 自定义包装类型
#[derive(Debug, Clone)]
struct BoundPairList(Vec<BoundPair>);

// 自定义迭代器
struct BoundPairRefIter<'a> {
    inner: std::slice::Iter<'a, BoundPair>,
}

// 为自定义迭代器实现Iterator trait，直接返回元组
impl<'a> Iterator for BoundPairRefIter<'a> {
    type Item = (&'a Bound, &'a Bound, i32);

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next().map(|bp| bp.into())
    }
}

// 为包装类型实现引用迭代的IntoIterator
impl<'a> IntoIterator for &'a BoundPairList {
    type Item = (&'a Bound, &'a Bound, i32);
    type IntoIter = BoundPairRefIter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        BoundPairRefIter {
            inner: self.0.iter(),
        }
    }
}

使用的时候完全不需要加任何map/转换步骤：

let list = BoundPairList(vec![instance.clone(), instance.clone()]);
for (a, b, c) in &list {
    println!("tuple: {:.?}", (a, b, c));
}

可选简化小技巧 #

如果不想加额外的trait/包装类型，也可以直接给BoundPair加一个关联方法，简化map的写法：

impl BoundPair {
    fn as_tuple(&self) -> (&Bound, &Bound, i32) {
        self.into()
    }
}

之后迭代时就可以写更短的map调用：

for (a,b,c) in vec.iter().map(BoundPair::as_tuple) {
    println!("tuple: {:.?}",(a,b,c));
}

内容的提问来源于stack exchange，提问作者Jonathan Woollett-light