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

Question

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

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

我想创建典型的三个迭代函数来获取Structs for Enum：一种.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::emptyand强制转换iter::once为slice::Iterand vec::IntoIter，或者这是否是正确的做法？

Answer 1

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

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()),
        }
    }
}

在操场上看到