advance/into-types/enum-int

[giscus[bot]]

advance/into-types/enum-int

https://course.rs/advance/into-types/enum-int.html

[bunnycodego]

谁能解释一下那个宏的代码?

[NicholasFirst]

这不是难为人嘛

[tonitrnel]

结合一些模版语法和正则勉强能读出来什么意思，但是写就GG。

macro_rules! back_to_enum {
    // (语法定义) => {模版文本}
    // 使用“$”号声明变量，$变量名:类型标记， “*”号表示会出现0-n个，“?”号表示会出现0-1个
    // meta标记是宏相关的，比如: #[allow(unused)]...
    // $name 枚举名、$vname 枚举属性名、$val 枚举属性值
    ($(#[$meta:meta])* $vis:vis enum $name:ident {
        $($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
    }) => {
        $(#[$meta])*
        $vis enum $name {
            $($(#[$vmeta])* $vname $(= $val)?,)*
        }

        impl std::convert::TryFrom<i32> for $name {
            type Error = ();

            fn try_from(v: i32) -> Result<Self, Self::Error> {
                match v {
                    $(x if x == $name::$vname as i32 => Ok($name::$vname),)*
                    _ => Err(()),
                }
            }
        }
    }
}

[lonexw]

不用太在意这块的复杂度了，如果未来真的需要写一些宏定义，照着文档和示例写就可以了

[chenjiafa9]

#[macro_export]
macro_rules! back_to_enum {
//个人见解 ：
//($(#[$meta:meta])* $vis:vis enum $name:ident {
// $($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
//})整体为一个匹配项
//第一段" $(#[$meta:meta])* " ： $( "#[]"为字面值,其中的匹配元属性$meta:meta):整个可以
//出现0次或多次（用于匹配enum上的派生属性，可以没有）
//第二段" $vis:vis enum $name:ident " : "$vis:vis"：匹配可见性限定符，有或没有pub都会匹配，
//"enum"：字面值(如果写成"$mod:ident"可捕获该结构类型关键字"struct/enum等"),对应上述"enum"关键字
//"$name:ident":标识符，用来匹配enum名称，对应上述"MyEnum"";
//第三段{$($(#[$vmeta:meta]) $vname:ident $(= $val:expr)?,)}：最外的括号{}为字面值，
//对应为上述枚举体的括号{},
//(1)$(#[$vmeta:meta]):与第一段描述基本一致，用来捕获单个枚举字段是否有派生属性，0个或多个；
//(2)$vname:ident : 匹配枚举单个字段名称，并被$vname捕获；对应上述例子的 A
//(3)$(= $val:expr)? ：其中里面的=号为字面值， $val:expr ：为匹配表达式，可以是一个值；
//且整体可以为0个或1个，对应上述例子的 = 1
//(4)"," : 分隔符 对应为A =1, 中的, 表示枚举字段间使用,号隔开
//(5)$($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)* :该整体匹配每个枚举字段，
// 可以0个或多个，上述例子中，会重复匹配三次，依次匹配对应上述 A=1,B,C,
($(#[$meta:meta])* $vis:vis enum $name:ident {
$($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
}) => {

    $(#[$meta])* //重复展开enum的派生属性：例如#[derive(Debug)]
    //下面三行代码在宏中声明一个枚举
    //其中“$($(#[$vmeta])* $vname $(= $val)?,)*”为第三段{}括号中的重复展开
    //展开依次为 A = 1,
    //          B,
    //          C,
    //最终为  enum MyEnum {
    //         A = 1,
    //         B,
    //         C,
    //     }
    $vis enum $name { //$vis 可有可无的pub关键字，例子中没有=空，$name = 替换为捕获的枚举名
        $($(#[$vmeta])* $vname $(= $val)?,)*
    }

    impl std::convert::TryFrom<i32> for $name { //为该枚举实现TryFrom<i32>特征
        type Error = ();
        fn try_from(v: i32) -> Result<Self, Self::Error> {
            match v {
        //$(x if x == $name::$vname as i32 => Ok($name::$vname),)* 重复展开三次，,x具体
        //为v的值，就是调用try_from(v)传入的值
        //依次是x if x == MyEnum::A as i32 => Ok(MyEnum::A)
        //      x if x == MyEnum::B as i32 => Ok(MyEnum::B)
        //      x if x == MyEnum::C as i32 => Ok(MyEnum::C)
                $(x if x == $name::$vname as i32 => Ok($name::$vname),)*
                _ => Err(()),
            }
        }
    }
}

}
//宏在编译完成后代码会展开，所以下面代码编译之后在运行时，与自己手动创建一个枚举并为其实现TryFrom
//效果一样
back_to_enum! {
#[derive(Debug)]
enum MyEnum {
A = 1,
B,
C,
}
}

fn main() {
let num = MyEnum::try_from(3).unwrap();
println!("{:?}", num); //输出结果为C
}

[silent-tan]

所以解释一下 A = 1 是什么语法？一开始我以为是宏定义的语法，但是看了开头的例子，没有用到宏之前，就有使用到这个语法了。

[zhwei820]

指定 enum 初始值 , 类似 golang iota = 1

[itfanr]

邪恶之王

[yangkkkk]

学rust这么久以赖，前面的复杂的都能忍，但是，一个整数与枚举转换这种非常常用的场景，都要引用第三方库。

[chunchunyd]

感觉TryFrom的用法还蛮直观的，而且又不是没有像c一样简单的用法，邪恶之王不就是吗=.=，但是这不就又回到了c的不安全

[qianyiwangmeng]

fn try_from(v: i32) -> Result<Self, Self::Error> {
    match v {
        x if x == MyEnum::A as i32 => Ok(MyEnum::A),
        x if x == MyEnum::B as i32 => Ok(MyEnum::B),
        x if x == MyEnum::C as i32 => Ok(MyEnum::C),
        _ => Err(()),
    }
}

这里的 x 是什么啊

[chunchunyd]

x就是v的不同模式，前面基础课里匹配守卫的语法

匹配守卫提供的额外条件

匹配守卫（match guard）是一个位于 match 分支模式之后的额外 if 条件，它能为分支模式提供更进一步的匹配条件。

这个条件可以使用模式中创建的变量：

let num = Some(4);

match num {
    Some(x) if x < 5 => println!("less than five: {}", x),
    Some(x) => println!("{}", x),
    None => (),
}

这个例子会打印出 less than five: 4。当 num 与模式中第一个分支匹配时，Some(4) 可以与 Some(x) 匹配，接着匹配守卫检查 x 值是否小于 5，因为 4 小于 5，所以第一个分支被选择。

相反如果 num 为 Some(10)，因为 10 不小于 5 ，所以第一个分支的匹配守卫为假。接着 Rust 会前往第二个分支，因为这里没有匹配守卫所以会匹配任何 Some 成员。

模式中无法提供类如 if x < 5 的表达能力，我们可以通过匹配守卫的方式来实现。

[pandaye]

TryInto + 宏解决这个问题在在实践中会用到吗？TryInto 里面的 match 代码感觉和外面的差不多啊，直接写有什么不妥当的地方吗？

[pandaye]

好吧，如果经常要这么 match 的话，先写 OK(XXX) 会比 x if x == XXX as T 短一点

[lihongtao1024]

感觉没有那么麻烦，也不需要第三方库啊。况且用了第三方库还是要写那么多代码，一点没方便。

#[repr(u8)]
#[derive(Debug)]
enum State {
    State0,
    State1,
    State2,
    State3,
    State4,
}

impl State {
    fn into_u8(self) -> u8 {
        self as u8
    }

    fn from_u8(v: u8) -> Option<State> {
        match v {
            0 => Some(State::State0),
            1 => Some(State::State1),
            2 => Some(State::State2),
            3 => Some(State::State3),
            4 => Some(State::State4),
            _ => None,
        }
    }
}

fn main() {
    let state = State::State3;

    let mut value = state.into_u8();
    println!("value = {:?}", value);

    value += 1;
    State::from_u8(value).map(|state| println!("state = {:?}", state));
}

[lihongtao1024]

还有一种写法，使用匹配守卫，更安全。

#[repr(u8)]
#[derive(Debug)]
enum State {
    State0,
    State1,
    State2,
    State3,
    State4,
}

impl State {
    fn into_u8(self) -> u8 {
        self as u8
    }

    fn from_u8(v: u8) -> Option<State> {
        match v {
            _ if State::State0 as u8 == v => Some(State::State0),
            _ if State::State1 as u8 == v => Some(State::State1),
            _ if State::State2 as u8 == v => Some(State::State2),
            _ if State::State3 as u8 == v => Some(State::State3),
            _ if State::State4 as u8 == v => Some(State::State4),
            _ => None,
        }
    }
}

fn main() {
    let state = State::State3;

    let mut value = state.into_u8();
    println!("value = {:?}", value);

    value += 1;
    State::from_u8(value).map(|state| println!("state = {:?}", state));
}

[zhangdekui]

有没有大佬解释下更安全在哪?

[duanyuluo]

还是你勤劳～这么多代码～～

[runzhi214]

摘自：stackOverflow

https://stackoverflow.com/questions/28028854/how-do-i-match-enum-values-with-an-integer

[rtpacks]

作者的本意应该在数字转换成枚举，而不是枚举转换成数字，所以方式多且复杂。

[runzhi214]

摘自：stackOverflow

https://stackoverflow.com/questions/28028854/how-do-i-match-enum-values-with-an-integer

[jian308]

为什么不直接写？TryFrom + 宏还得绕一圈

let x = MyEnum::C as i32;
match x {
        i if i==MyEnum::A as i32 => println!("a"),
        i if i==MyEnum::B as i32 => println!("b"),
        i if i==MyEnum::C as i32 => println!("c"),
        _ => eprintln!("unknown number"),
}

[yinchyu]

let mut x=HashMap::new();
x.insert(MyEnum::C, 3);
x.insert(MyEnum::A, 3);
x.insert(MyEnum::B, 3);
let mut y=HashMap::new();
y.insert( 3,MyEnum::C);
y.insert( 2,MyEnum::A,);
y.insert( 1,MyEnum::B);
let x = MyEnum::C;
let z = x as i32;
// match the enum that came from an int
match y[&z] {
MyEnum::A => { println!("Found A"); }
MyEnum::B => { println!("Found B"); }
MyEnum::C => { println!("Found C"); }
}

[godpiao]

如果 std::mem::transmute 转入了 不在enum里的整数，会怎样

[ADkun]

你可以试试

#[derive(Debug)]
enum Taste {
    Saulty,
    Sweet,
}

pub fn test() {
    for i in 0..4 {
        let taste: Taste = unsafe { std::mem::transmute(i as u8) };
        println!("{i}: {taste:?}");
    }
}

[yanyunwu]

666