Question

标准库中的集合类型（std::collections）提供了不同的迭代方式，以供选择。

• iter : &T 。
• iter_mut : &mut T 。
• into_iter : T 。

fn main() {
  let v = vec![10, 11, 12, 13];

  for e in &v {       // v.iter()
    println!("{}", e);
  }
}

fn main() {
  let mut v = vec![10, 11, 12, 13];

  for e in &mut v {     // v.iter_mut()
    *e += 1;
  }

  println!("{:?}", v);
}

fn main() {
  let v = vec![10, 11, 12, 13];

  for e in v {       // v.into_iter()
    println!("{}", e);
  }

  // println!("{:?}", v);
  //          ^ value borrowed here after move
}

适配器

适配器（adapter）让我们以链式风格处理迭代器。

fn main() {
  let v = vec![10, 11, 12, 13];
  
  v.iter()
    .take(2)
    .map(|x| x + 1)
    .for_each(|x| println!("{}", x));
}

迭代器是惰性的，如果没有 for_each 或 for 循环，那么什么都不会做。

warning: unused `std::iter::Take` that must be used
   |
15 | /   v.iter()
16 | |     .take(2)
17 | |     .map(|x| x + 1);
   | |________________________^
   |
   = note: iterators are lazy and do nothing unless consumed

自定义

实现 Iterator 特征来实现自己的迭代器。通常独立实现，避免对原对象状态造成干扰。

// 元组结构
struct Data(Vec<i32>);

impl Data {
  
  // 返回新的迭代器。
  fn iter(&self) -> DataIterator {
    DataIterator{ data: self, index: 0 }
  }
}

/* ------------------------------------------------- */

// 迭代器
struct DataIterator<'a> {
  data : &'a Data,
  index: usize,
}

// 迭代器特征实现
impl Iterator for DataIterator<'_> {
  type Item = i32;

  fn next(&mut self) -> Option<Self::Item> {
    if self.index >= self.data.0.len() { return None }
    
    let x = self.data.0[self.index];
    self.index += 1;

    Some(x)
  }
}

/* ------------------------------------------------- */

fn main() {  
  let d = Data(vec![1, 2, 3, 4]);
  
  // 循环
  for x in d.iter() {
    println!("{:?}", x);
  }

  // 适配器
  d.iter().for_each(|x| println!("{:?}", x));

  // 转换
  use std::iter::FromIterator;
  assert_eq!(Vec::from_iter(d.iter()), [1, 2, 3, 4]);
}