Rust 中的可迭代特性：探索 Collection 和 Iterable

Rust 提供了强大的类型系统，但在可迭代特性上仍有一些可改进之处。

本文将讨论 Collection 和 Iterable 特性的定义与实现，以及它们在提升代码通用性与可复用性上的作用。

背景

在 Rust 的核心库中，我们已经有了 Iterator 和 IntoIterator 特性。然而，对于可以多次迭代的集合类型（Collection）或通用的可迭代类型（Iterable），目前还缺乏统一的特性支持。我们将深入探讨这些特性的重要性和实现方式。

核心概念

Iterator

Iterator 特性用于逐步遍历集合中的元素或计算结果。它是一种懒加载模型，仅在调用消费方法时才执行计算。

常见的 Iterator 方法包括：

迭代器到迭代器的转换：filter、map、flat_map。
迭代器的消费方法：collect、reduce、fold。

let numbers = vec![1, 2, 3];
let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
println!("{:?}", doubled); // [2, 4, 6]

IntoIterator

IntoIterator 特性允许将类型转换为迭代器：

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    fn into_iter(self) -> Self::IntoIter;
}

它支持三种实现方式：

消费自身：x.into_iter()。
消费不可变引用：(&x).into_iter()。
消费可变引用：(&mut x).into_iter()。

定义 Collection 和 Iterable 特性

Collection 和 CollectionMut 特性

Collection 表示可以反复生成共享引用迭代器的集合，CollectionMut 进一步扩展为支持生成可变引用迭代器。

trait Collection {
    type Item;
    type Iter<'i>: Iterator<Item = &'i Self::Item>
    where
        Self: 'i;

    fn iter(&self) -> Self::Iter<'_>;
}

trait CollectionMut: Collection {
    type IterMut<'i>: Iterator<Item = &'i mut Self::Item>
    where
        Self: 'i;

    fn iter_mut(&mut self) -> Self::IterMut<'_>;
}

通过 IntoIterator 的实现，可以简洁地为所有符合条件的集合实现这些特性：

impl<X> Collection for X
where
    X: IntoIterator,
    for<'a> &'a X: IntoIterator<Item = &'a <X as IntoIterator>::Item>,
{
    type Item = <X as IntoIterator>::Item;
    type Iter<'i> = <&'i X as IntoIterator>::IntoIter;

    fn iter(&self) -> Self::Iter<'_> {
        <&X as IntoIterator>::into_iter(self)
    }
}

impl<X> CollectionMut for X
where
    X: IntoIterator,
    for<'a> &'a mut X: IntoIterator<Item = &'a mut <X as IntoIterator>::Item>,
{
    type IterMut<'i> = <&'i mut X as IntoIterator>::IntoIter;

    fn iter_mut(&mut self) -> Self::IterMut<'_> {
        <&mut X as IntoIterator>::into_iter(self)
    }
}

Iterable 特性

Iterable 是对更广泛可迭代类型的定义，支持生成值迭代器，而不是引用迭代器。

trait Iterable {
    type Item;
    type Iter: Iterator<Item = Self::Item>;

    fn iter(&self) -> Self::Iter;
}

实现方式如下：

impl<'a, X> Iterable for &'a X
where
    &'a X: IntoIterator,
{
    type Item = <&'a X as IntoIterator>::Item;
    type Iter = <&'a X as IntoIterator>::IntoIter;

    fn iter(&self) -> Self::Iter {
        self.into_iter()
    }
}

示例

Collection 示例

以下示例展示了如何使用 Collection 计算集合的统计信息：

fn statistics(numbers: &impl Collection<Item = i64>) -> Stats {
    let count = numbers.iter().count() as i64;
    let mean = numbers.iter().sum::<i64>() / count;
    let sum_sq_errors: i64 = numbers.iter().map(|x| (x - mean) * (x - mean)).sum();
    let std_dev = f64::sqrt(sum_sq_errors as f64 / (count - 1) as f64) as i64;

    Stats { count: count as usize, mean, std_dev }
}

支持的集合类型包括：

数组和向量
标准库集合（如 HashSet、VecDeque）
第三方集合（如 SmallVec、ArrayVec）

CollectionMut 示例

以下示例展示了如何使用 CollectionMut 修改集合中的元素：

fn increment_by_sum(numbers: &mut impl CollectionMut<Item = i32>) {
    let sum: i32 = numbers.iter().sum();
    for x in numbers.iter_mut() {
        *x += sum;
    }
}

Iterable 示例

以下示例展示了使用 Iterable 的灵活性，包括对范围和自定义生成器的支持：

fn statistics(numbers: impl Iterable<Item = i64>) -> Stats {
    /* 与 Collection 示例相同 */
}

statistics(7..21); // 支持范围
statistics(FibUntil(10)); // 自定义生成器

优势与结论

优势

自动实现：无需额外配置，集合类型可以自动实现 Collection 和 CollectionMut。
广泛适用：支持标准集合、自定义集合和生成器类型。
灵活性：通过 Iterable 扩展了迭代器的应用范围。

总结

通过引入 Collection 和 Iterable 特性，我们显著提升了代码的复用性和通用性。 Rust 的类型系统为实现这些特性提供了极大的便利，再次展现了其强大的能力 ❤️🦀。

链接

Missing Iterable Traits