在 Rust 中，有没有一种方法可以遍历枚举的值？

问题描述 投票：0回答：9

我来自 Java 背景，我可能有类似 

enum Direction { NORTH, SOUTH, EAST, WEST}
的东西，我可以用增强的 for 循环依次对每个值做一些事情，比如：

for(Direction dir : Direction.values())  {
    //do something with dir
}

我想用 Rust 枚举做类似的事情。

enums iteration rust
9个回答
138
投票

您可以使用 strum crate 轻松地遍历枚举的值。

use strum::IntoEnumIterator; // 0.17.1
use strum_macros::EnumIter; // 0.17.1

#[derive(Debug, EnumIter)]
enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST,
}

fn main() {
    for direction in Direction::iter() {
        println!("{:?}", direction);
    }
}

输出：

NORTH
SOUTH
EAST
WEST
58
投票

如果枚举是 C-like（如您的示例），那么您可以为每个变体创建一个

static
数组并返回对它们的引用的迭代器：

use self::Direction::*;
use std::slice::Iter;

#[derive(Debug)]
pub enum Direction {
    North,
    South,
    East,
    West,
}

impl Direction {
    pub fn iterator() -> Iter<'static, Direction> {
        static DIRECTIONS: [Direction; 4] = [North, South, East, West];
        DIRECTIONS.iter()
    }
}

fn main() {
    for dir in Direction::iterator() {
        println!("{:?}", dir);
    }
}

如果你使枚举实现

Copy
，你可以使用
Iterator::copied
并返回
impl Trait
以获得值的迭代器：

impl Direction {
    pub fn iterator() -> impl Iterator<Item = Direction> {
        [North, South, East, West].iter().copied()
    }
}

另见：

55
投票

没有，没有。我认为这是因为 Rust 中的枚举比 Java 中的枚举强大得多——它们实际上是成熟的代数数据类型。例如，您希望如何迭代此枚举的值：

enum Option<T> {
    None,
    Some(T)
}

?

它的第二个成员，

Some
，不是一个静态常量——你用它来创建
Option<T>
的值：

let x = Some(1);
let y = Some("abc");

所以没有明智的方法可以迭代 any 枚举的值。

当然，我认为，可以在编译器中添加对 static 枚举（即仅包含静态项的枚举）的特殊支持，因此它会生成一些返回枚举值的函数或带有它们的静态向量，但我认为编译器的额外复杂性是不值得的。

如果你真的想要这个功能，你可以写一个自定义语法扩展（见this问题）。此扩展应接收标识符列表并输出一个枚举和一个静态常量向量，这些标识符作为内容。常规宏在某种程度上也可以工作，但据我所知，你不能将具有多重性的宏参数转录两次，所以你必须手动编写枚举元素两次，这很不方便。

这个问题可能也很有趣：#5417

当然，您始终可以编写代码来手动返回枚举元素列表。

11
投票

我在 crate 

plain_enum
中实现了基本功能。

可用于声明类 C 的枚举，如下所示：

#[macro_use]
extern crate plain_enum;

plain_enum_mod!(module_for_enum, EnumName {
    EnumVal1,
    EnumVal2,
    EnumVal3,
});

然后将允许您执行以下操作：

for value in EnumName::values() {
    // do things with value
}

let enummap = EnumName::map_from_fn(|value| {
    convert_enum_value_to_mapped_value(value)
})
7
投票

您可以使用关联常量：

impl Direction {
    const VALUES: [Self; 4] = [Self::NORTH, Self::SOUTH, Self::EAST, Self::WEST];
}

fn main() {
    for direction in Direction::VALUES.iter().copied() {
        todo!();
    }
}
2
投票

如果您不想导入第三方 crate，您可以制作自己的宏来导入。这是我实现它的方法（可能有改进的方法）：

macro_rules! iterable_enum {
    ($visibility:vis, $name:ident, $($member:tt),*) => {
        $visibility enum $name {$($member),*}
        impl $name {
            fn iterate() -> Vec<$name> {
                vec![$($name::$member,)*]
            }
        }
    };
    ($name:ident, $($member:tt),*) => {
        iterable_enum!(, $name, $($member),*)
    };
}

然后你可以做：

iterable_enum!(pub, EnumName, Value1, Value2, Value3);

fn main() {
    for member in EnumName::iterate() {
        // ...
    }
}

此实现仅限于简单的枚举。考虑以下枚举，你将如何迭代它？：

enum MoreComplexEnum<T1, T2> {
    One(T1),
    Two(T2),
    Other,
    Both(T1, T2),
    Error(String),
}

由于 Rust 中枚举的强大功能，可能很难实现完美的可迭代枚举，因为它们不像 C 或 Java 中的简单枚举。

2
投票

enum-iterator 板条箱有助于迭代枚举器。

0
投票

这是我对@Ahmed Merez 的回答的看法：

  • 不在堆上分配
  • 是常数
  • 接受（几乎）一个实际的枚举作为输入（需要 
    vis
    因为 Rust 似乎不喜欢带有 
    error: repetition matches empty token tree
    错误的空可见性参数） 包括：
    • 导出输入
    • 属性属性
#[macro_export]
macro_rules! count {
    () => (0usize);
    ( $x:tt $($xs:tt)* ) => (1usize + $crate::count!($($xs)*));
}

/// https://stackoverflow.com/a/64678145/10854888
macro_rules! iterable_enum {
    ($(#[$derives:meta])* $(vis $visibility:vis)? enum $name:ident { $($(#[$nested_meta:meta])* $member:ident),* }) => {
        const count_members:usize = $crate::count!($($member)*);
        $(#[$derives])*
        $($visibility)? enum $name {
            $($(#[$nested_meta])* $member),*
        }
        impl $name {
            pub const fn iter() -> [$name; count_members] {
                [$($name::$member,)*]
            }
        }
    };
}


fn main() {
    iterable_enum! {
        #[derive(Debug, serde::Deserialize)]
        vis pub(crate) enum X {
            #[serde(rename="a")]
            A,
            B
        }
    }
    
    for x in X::iter() {
        dbg!(x);
    }
}
0
投票

我对@koral 回答的变体

  • 不需要
    vis
  • 实现
    into_iter
    ，它返回一个实际的迭代器而不是数组
macro_rules! iterable_enum {(
  $(#[$derives:meta])*
  $pub:vis enum $name:ident {
    $(
      $(#[$nested_meta:meta])*
      $member:ident,
    )*
  }) => {
    const _MEMBERS_COUNT:usize = iterable_enum!(@count $($member)*);
    $(#[$derives])*
    $pub enum $name {
      $($(#[$nested_meta])* $member),*
    }
    impl $name {
      pub fn into_iter() -> std::array::IntoIter<$name, _MEMBERS_COUNT> {
        [$($name::$member,)*].into_iter()
      }
    }
  };
  (@count) => (0usize);
  (@count  $x:tt $($xs:tt)* ) => (1usize + iterable_enum!(@count $($xs)*));
}

fn main() {
  iterable_enum! {
  #[derive(Debug, serde::Deserialize)]
  pub enum X {
    #[serde(rename="a")]
    A,
    B,
  }}
    
  X::into_iter().fold(...);
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.