我来自 Java 背景,我可能有类似
enum Direction { NORTH, SOUTH, EAST, WEST}
的东西,我可以用增强的 for 循环依次对每个值做一些事情,比如:
for(Direction dir : Direction.values()) {
//do something with dir
}
我想用 Rust 枚举做类似的事情。
您可以使用 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
如果枚举是 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()
}
}
另见:
没有,没有。我认为这是因为 Rust 中的枚举比 Java 中的枚举强大得多——它们实际上是成熟的代数数据类型。例如,您希望如何迭代此枚举的值:
enum Option<T> {
None,
Some(T)
}
?
它的第二个成员,
Some
,不是一个静态常量——你用它来创建Option<T>
的值:
let x = Some(1);
let y = Some("abc");
所以没有明智的方法可以迭代 any 枚举的值。
当然,我认为,可以在编译器中添加对 static 枚举(即仅包含静态项的枚举)的特殊支持,因此它会生成一些返回枚举值的函数或带有它们的静态向量,但我认为编译器的额外复杂性是不值得的。
如果你真的想要这个功能,你可以写一个自定义语法扩展(见this问题)。此扩展应接收标识符列表并输出一个枚举和一个静态常量向量,这些标识符作为内容。常规宏在某种程度上也可以工作,但据我所知,你不能将具有多重性的宏参数转录两次,所以你必须手动编写枚举元素两次,这很不方便。
这个问题可能也很有趣:#5417
当然,您始终可以编写代码来手动返回枚举元素列表。
我在 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)
})
您可以使用关联常量:
impl Direction {
const VALUES: [Self; 4] = [Self::NORTH, Self::SOUTH, Self::EAST, Self::WEST];
}
fn main() {
for direction in Direction::VALUES.iter().copied() {
todo!();
}
}
如果您不想导入第三方 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 中的简单枚举。
enum-iterator 板条箱有助于迭代枚举器。
这是我对@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);
}
}
我对@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(...);
}