如何从枚举中选择随机值？

Question

spinners 板条箱有一个 enum，其中包含大量可能的微调器。

这是枚举（除了顶部和底部 4 之外的所有值都被跳过）：

pub enum Spinners {
    Dots,
    Dots2,
    Dots3,
    Dots4,
    ...
    Shark,
    Dqpb,
    Weather,
    Christmas,
}

一个新的微调器很容易创建：

extern crate spinners;

use spinners::{Spinner, Spinners};
use std::thread::sleep;
use std::time::Duration;

fn main() {
    let sp = Spinner::new(Spinners::Dots9, "Waiting for 3 seconds".into());
    sleep(Duration::from_secs(3));
    sp.stop();
}

但是，我希望随机选择一个微调器，这不起作用：

let spinner_enum = rng.choose(Spinners).unwrap_or(&Spinners::Dots9);

因为：

error[E0423]: expected value, found enum `Spinners`

let spinner_enum = rng.choose(Spinners).unwrap_or(&Spinners::Dots9);
                              ^^^^^^^^ not a value

如何随机选择一个枚举值，并使用它来显示随机微调器？

Answer 1

你自己的枚举

像 Rust 中的大多数抽象一样，随机值生成是由特征驱动的。对于任何特定类型，实现 trait 都是相同的，唯一的区别是 trait 的方法和类型是什么。

兰德 0.5、0.6、0.7 和 0.8

使用您的枚举作为类型参数来实现Distribution。您还需要选择特定类型的分发； Standard 是一个不错的默认选择。然后使用任意一种方法生成一个值，比如rand::random：

use rand::{
    distributions::{Distribution, Standard},
    Rng,
}; // 0.8.0

#[derive(Debug)]
enum Spinner {
    One,
    Two,
    Three,
}

impl Distribution<Spinner> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Spinner {
        // match rng.gen_range(0, 3) { // rand 0.5, 0.6, 0.7
        match rng.gen_range(0..=2) { // rand 0.8
            0 => Spinner::One,
            1 => Spinner::Two,
            _ => Spinner::Three,
        }
    }
}

fn main() {
    let spinner: Spinner = rand::random();
    println!("{:?}", spinner);
}

兰德 0.4

为您的枚举实现Rand，然后使用任何方法生成一个值，例如Rng::gen：

extern crate rand; // 0.4.2

use rand::{Rand, Rng};

#[derive(Debug)]
enum Spinner {
    One,
    Two,
    Three,
}

impl Rand for Spinner {
    fn rand<R: Rng>(rng: &mut R) -> Self {
        match rng.gen_range(0, 3) {
            0 => Spinner::One,
            1 => Spinner::Two,
            _ => Spinner::Three,
        }
    }
}

fn main() {
    let mut rng = rand::thread_rng();
    let spinner: Spinner = rng.gen();
    println!("{:?}", spinner);
}

导出

rand_derive crate 可以消除对这些样板的需要，但对于 Rand 0.5 不存在。

extern crate rand;
#[macro_use]
extern crate rand_derive;

use rand::Rng;

#[derive(Debug, Rand)]
enum Spinner {
    One,
    Two,
    Three,
}
    
fn main() {
    let mut rng = rand::thread_rng();
    let spinner: Spinner = rng.gen();
    println!("{:?}", spinner);
}

别人的枚举

由于您不控制枚举，因此您必须将 something 复制到您的代码中才能引用它。您可以从中创建一个枚举数组和choose：

use rand::seq::SliceRandom; // 0.8.0

mod another_crate {
    #[derive(Debug)]
    pub enum Spinner {
        One,
        Two,
        Three,
    }
}

fn main() {
    let mut rng = rand::thread_rng();
    let spinners = [
        another_crate::Spinner::One,
        another_crate::Spinner::Two,
        another_crate::Spinner::Three,
    ];
    let spinner = spinners.choose(&mut rng).unwrap();
    println!("{:?}", spinner);
}

您可以在本地复制整个枚举，为此实现 Rand，然后有一个方法可以转换回其他 crates 表示。

use rand::{
    distributions::{Distribution, Standard},
    Rng,
}; // 0.8.0

mod another_crate {
    #[derive(Debug)]
    pub enum Spinner {
        One,
        Two,
        Three,
    }
}

enum Spinner {
    One,
    Two,
    Three,
}

impl From<Spinner> for another_crate::Spinner {
    fn from(other: Spinner) -> another_crate::Spinner {
        match other {
            Spinner::One => another_crate::Spinner::One,
            Spinner::Two => another_crate::Spinner::Two,
            Spinner::Three => another_crate::Spinner::Three,
        }
    }
}

impl Distribution<Spinner> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Spinner {
        match rng.gen_range(0..=2) {
            0 => Spinner::One,
            1 => Spinner::Two,
            _ => Spinner::Three,
        }
    }
}

fn main() {
    let spinner = another_crate::Spinner::from(rand::random::<Spinner>());
    println!("{:?}", spinner);
}

您可以数数旋转器的数量并进行匹配：

use rand::Rng; // 0.8.0

mod another_crate {
    #[derive(Debug)]
    pub enum Spinner {
        One,
        Two,
        Three,
    }
}

fn rando<R: Rng>(mut rng: R) -> another_crate::Spinner {
    match rng.gen_range(0..=2) {
        0 => another_crate::Spinner::One,
        1 => another_crate::Spinner::Two,
        _ => another_crate::Spinner::Three,
    }
}

fn main() {
    let mut rng = rand::thread_rng();
    let spinner = rando(&mut rng);
    println!("{:?}", spinner);
}

您可以实现一个 newtype 并为此实现随机生成：

use rand::{distributions::Standard, prelude::*}; // 0.8.0

mod another_crate {
    #[derive(Debug)]
    pub enum Spinner {
        One,
        Two,
        Three,
    }
}

struct RandoSpinner(another_crate::Spinner);

impl Distribution<RandoSpinner> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> RandoSpinner {
        RandoSpinner(match rng.gen_range(0..=2) {
            0 => another_crate::Spinner::One,
            1 => another_crate::Spinner::Two,
            _ => another_crate::Spinner::Three,
        })
    }
}

fn main() {
    let RandoSpinner(spinner) = rand::random();
    println!("{:?}", spinner);
}

另见：

• How do I implement a trait I don't own for a type I don't own?

Answer 2

由于Shepmaster asked，我可以建议另外几个选项。

不幸的是，rng.choose(Spinners) 无法工作，因为无法迭代枚举值；见：In Rust, is there a way to iterate through the values of an enum?

您大概可以使用strum 的EnumIter 来允许迭代。在 Rand 0.4 和 0.5 中，choose 不支持迭代器，但您可以将所有选项收集到 Vec 或枚举并匹配索引。在 Rand 0.6 中，将有一个变体 choose 支持迭代器，尽管它可能会很慢（取决于我们是否可以针对 ExactSizeIterators 优化它）。

use rand::prelude::*;

#[derive(EnumIter)]
enum Spinner { ... }

let mut rng = thread_rng();

let options = Spinner::iter().collect::<Vec<_>>();
let choice = rng.choose(&options);

// or:
let index = rng.gen_range(0, MAX);
let choice = Spinner::iter().enumerate().filter(|(i, _)| i == index).map(|(_, x)| x).next().unwrap();

// with Rand 0.6, though this may be slow:
let choice = Spinner::iter().choose(&mut rng);
// collecting may be faster; in Rand 0.6 this becomes:
let choice = Spinner::iter().collect::<Vec<_>>().choose(&mut rng);

另一种选择是使用 num 的 FromPrimitive trait 和 num-derive：

#[derive(FromPrimitive)]
enum Spinner { ... }

let choice = Spinner::from_u32(rng.gen_range(0, MAX)).unwrap();