如何为可迭代变体的枚举实现 IntoIterator？

Question

我有一个具有不同变体可能性的枚举，如下所示：

pub enum Enum {
  Empty,
  Single(Struct),
  Multi(Vec<Struct>),
}

我想创建典型的三个迭代函数来获取Enum的Struct ：一个.iter()用于引用的迭代器，以及两种风格的.into_iter()来获取引用和值的迭代器。 如何做到这一点？

这是我失败的尝试：

use std::{iter, slice, vec};

#[derive(Debug)]
pub struct Struct(u32);

#[derive(Debug)]
pub enum Enum {
  Empty,
  Single(Struct),
  Multi(Vec<Struct>),
}

impl Enum {
  fn iter(&self) -> slice::Iter<'_, Struct> {
    match self {
      Enum::Empty => iter::empty(),
      Enum::Single(s) => iter::once(s),
      Enum::Multi(v) => v.iter(),
    }
  }
}

impl IntoIterator for Enum {
  type Item = Struct;
  type IntoIter = vec::IntoIter<Struct>;

  fn into_iter(self) -> Self::IntoIter {
    match self {
      Enum::Empty => iter::empty(),
      Enum::Single(s) => iter::once(s),
      Enum::Multi(v) => v.into_iter(),
    }
  }
}

impl<'a> IntoIterator for &'a Enum {
  type Item = &'a Struct;
  type IntoIter = slice::Iter<'a, Struct>;

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

fn main() {
  let enums = vec![
    Enum::Empty,
    Enum::Single(Struct(1)),
    Enum::Multi(vec![Struct(2), Struct(3)])];
  for e in enums {
    for s in e.iter() {
      println!(".iter() over refs: {:?}", s);
    }
    for s in &e {  // leverages IntoIterator for &'a Enum
      println!(".into_iter() over refs: {:?}", s);
    }
    for s in e {  // leverages IntoIterator for Enum
      println!(".into_iter() moves: {:?}", s);
    }
  }
}

^操场

我看不到如何强制iter::empty和iter::once进入slice::Iter和vec::IntoIter ，或者这甚至是正确的事情吗？

Answer 1

在这种情况下，所有这些变体都可以用切片表示或轻松转换为Vec s。 所以你可以这样做，然后直接使用他们的迭代器。

impl IntoIterator for Enum {
    type Item = Struct;
    type IntoIter = vec::IntoIter<Struct>;
  
    fn into_iter(self) -> vec::IntoIter<Struct> {
        let vec = match self {
            Enum::Empty => Vec::new(),
            Enum::Single(single) => vec![single],
            Enum::Multi(vec) => vec,
        };
        
        vec.into_iter()
    }
}

impl<'a> IntoIterator for &'a Enum {
  type Item = &'a Struct;
  type IntoIter = slice::Iter<'a, Struct>;

    fn into_iter(self) -> slice::Iter<'a, Struct> {
        let slice = match self {
            Enum::Empty => &[],
            Enum::Single(single) => std::slice::from_ref(single),
            Enum::Multi(vec) => vec.as_slice(),
        };
        
        slice.iter()
    }
}

在操场上看到它。

---

如果您实际上有足够不同的变体而无法将它们强制转换为现有迭代器，则可以将迭代器实现为其他迭代器的枚举。 这就是它的样子：

pub enum EnumIntoIter {
    Empty(std::iter::Empty<Struct>),
    Single(std::iter::Once<Struct>),
    Multi(std::vec::IntoIter<Struct>),
}

impl Iterator for EnumIntoIter {
    type Item = Struct;
    
    fn next(&mut self) -> Option<Struct> {
        match self {
            EnumIntoIter::Empty(iter) => iter.next(),
            EnumIntoIter::Single(iter) => iter.next(),
            EnumIntoIter::Multi(iter) => iter.next(),
        }
    }
}

impl IntoIterator for Enum {
    type Item = Struct;
    type IntoIter = EnumIntoIter;
  
    fn into_iter(self) -> EnumIntoIter {
        match self {
            Enum::Empty => EnumIntoIter::Empty(std::iter::empty()),
            Enum::Single(single) => EnumIntoIter::Single(std::iter::once(single)),
            Enum::Multi(vec) => EnumIntoIter::Multi(vec.into_iter()),
        }
    }
}

pub enum EnumIter<'a> {
    Empty(std::iter::Empty<&'a Struct>),
    Single(std::iter::Once<&'a Struct>),
    Multi(std::slice::Iter<'a, Struct>),
}

impl<'a> Iterator for EnumIter<'a> {
    type Item = &'a Struct;
    
    fn next(&mut self) -> Option<&'a Struct> {
        match self {
            EnumIter::Empty(iter) => iter.next(),
            EnumIter::Single(iter) => iter.next(),
            EnumIter::Multi(iter) => iter.next(),
        }
    }
}

impl<'a> IntoIterator for &'a Enum {
    type Item = &'a Struct;
    type IntoIter = EnumIter<'a>;
  
    fn into_iter(self) -> EnumIter<'a> {
        match self {
            Enum::Empty => EnumIter::Empty(std::iter::empty()),
            Enum::Single(single) => EnumIter::Single(std::iter::once(single)),
            Enum::Multi(vec) => EnumIter::Multi(vec.iter()),
        }
    }
}

在操场上看