无需克隆输入可迭代对象，如何实现泛型Totalled结构体？

原代码的核心问题在于：当你调用data.into_iter()时，data是&T类型，其对应的IntoIterator实现返回的是遍历引用的迭代器，但你的类型约束仅要求T::Item能直接迭代出u32，这就导致类型不匹配——此时迭代得到的inner是&T::Item，而非T::Item，无法直接调用inner.into_iter()得到u32的迭代器。以下是两种符合你需求的解决方案：

方案一：存储可迭代对象的副本（计算总和时不克隆输入） #

调整结构体的类型约束，允许通过引用遍历输入数据计算总和，仅在存储时克隆一次输入对象，避免计算过程中的内存浪费：

use std::collections::{BTreeSet, LinkedList};

struct Totalled<T>
where
    T: IntoIterator + Clone,
    // 约束&T可以生成迭代器
    for<'a> &'a T: IntoIterator,
    // 约束&T的迭代项可以生成&u32的迭代器
    for<'a> <&'a T as IntoIterator>::Item: IntoIterator<Item = &'a u32>,
{
    data: T,
    total: u32,
}

impl<T> Totalled<T>
where
    T: IntoIterator + Clone,
    for<'a> &'a T: IntoIterator,
    for<'a> <&'a T as IntoIterator>::Item: IntoIterator<Item = &'a u32>,
{
    fn new(data: &T) -> Self {
        let total = data
            .into_iter()
            // 将&u32转换为u32，无需克隆整个内部集合
            .map(|inner| inner.into_iter().max().copied().unwrap_or(0))
            .sum();
        Totalled {
            data: data.clone(),
            total,
        }
    }
}

fn main() {
    let mut list = LinkedList::new();
    list.push_back(BTreeSet::from([1, 2, 3]));
    list.push_back(BTreeSet::from([4, 5]));

    let totalled = Totalled::new(&list);
    println!("Total: {}", totalled.total); // 输出 Total: 8
    for set in totalled.data {
        println!("{:?}", set);
    }
}

关键改动：

• 使用for<'a>生命周期约束，确保&T及其迭代项都能通过引用遍历
• 用copied()将&u32转换为u32，避免克隆内部集合
• 计算总和时仅遍历输入的引用，仅在存储副本时克隆一次输入

方案二：存储可迭代对象的引用（完全避免克隆） #

如果仅将结构体作为排序标签使用，存储引用是更高效的选择，完全无需克隆：

use std::collections::{BTreeSet, LinkedList};

// 生命周期参数绑定引用的存活时间
struct Totalled<'a, T>
where
    &'a T: IntoIterator,
    <&'a T as IntoIterator>::Item: IntoIterator<Item = &'a u32>,
{
    data: &'a T,
    total: u32,
}

impl<'a, T> Totalled<'a, T>
where
    &'a T: IntoIterator,
    <&'a T as IntoIterator>::Item: IntoIterator<Item = &'a u32>,
{
    fn new(data: &'a T) -> Self {
        let total = data
            .into_iter()
            .map(|inner| inner.into_iter().max().copied().unwrap_or(0))
            .sum();
        Totalled { data, total }
    }
}

fn main() {
    let mut list = LinkedList::new();
    list.push_back(BTreeSet::from([1, 2, 3]));
    list.push_back(BTreeSet::from([4, 5]));

    let totalled = Totalled::new(&list);
    println!("Total: {}", totalled.total); // 输出 Total: 8
    // 遍历引用时需使用iter()或直接遍历引用
    for set in totalled.data.iter() {
        println!("{:?}", set);
    }
}

此方案优势：

• 完全不涉及克隆，内存占用最低
• 结构体仅作为排序标签时，引用方式更贴合需求
• 遍历引用时需调用iter()或使用for set in &totalled.data，因为data是不可变引用

内容的提问来源于stack exchange，提问作者Ben Jaguar Marshall