那为啥上面这段代码可以输出？

元组型 variant，你注意到我说的定语“元组”了吗？

When referred to, a function item, or the constructor of a tuple-like struct or enum variant, yields a zero-sized value of its function item type.

src: https://doc.rust-lang.org/reference/types/function-item.html

不同种类的 enum，对应的 discriminant 规则是不一样的（无数据的 enum 的确可以 as integer 来充当判别式，但有数据的 enum 会不一样）：

• https://doc.rust-lang.org/reference/items/enumerations.html#accessing-discriminant
• https://doc.rust-lang.org/reference/type-layout.html#primitive-representations
• https://rust-lang.github.io/unsafe-code-guidelines/layout/enums.html

如果想比较同类 varaint，discriminant 或许是你想要的。

use std::mem::discriminant;
#[repr(u8)]
enum PokerCard {
    Clubs(u8) = 4,
    Spades(u8) = 3,
    Diamonds(char) = 2,
    Hearts(char) = 1,
}
fn main() {
    let c1 = PokerCard::Spades(5);
    let c2 = PokerCard::Diamonds('A');
    dbg!(
        discriminant(&c1) != discriminant(&c2),
        discriminant(&c1) == discriminant(&PokerCard::Spades(3))
    );
}

应该是只有简单的enum才可以表达为整数，就是不含子元素的。不过即使是这种含子元素的，enum内部实现是有一个整数类型tag字段的，调试模式的时候可以看到，具体怎么用我就不清楚了。

这里评论区的讨论我绝对很有用

关于枚举和整数的转换，可以参考Rust圣经

enum Number {
    Zero,
    One,
    Two,
}

enum Number1 {
    Zero = 0,
    One,
    Two,
}

// C-like enum
enum Number2 {
    Zero = 0,
    One = 1,
    Two = 2,
}


fn main() {
    // a enum variant can be converted to a integer by `as`
    assert_eq!(Number::One as u8, Number1::One as u8);
    assert_eq!(Number1::One as u8, Number2::One as u8);
} 

那为啥上面这段代码可以输出？

--
👇
苦瓜小仔: 那只是一个函数指针的地址而已，只不过被溢出了。结果不同取决于整数溢出的配置方式。

元组结构体和元组型 variant，都可以作为构造函数，而函数与函数指针隐式强制转换，所以你的代码变成了

println!("{}", PokerCard::Spades as (fn(_) -> _) as u8);

那只是一个函数指针的地址而已，只不过被溢出了。结果不同取决于整数溢出的配置方式。

元组结构体和元组型 variant，都可以作为构造函数，而函数与函数指针隐式强制转换，所以你的代码变成了

println!("{}", PokerCard::Spades as (fn(_) -> _) as u8);

PokerCard::Spades其实是一个函数，你as出来的其实是个函数地址。 要想得到判别式可以自己按照对应类型的布局的实现自己进行指针操作。

#![feature(unboxed_closures)]
#[derive(Debug,PartialEq)]
#[repr(u8)]
enum PokerCard {
    Clubs(u8) =3,
    Spades(u8) =7,
    Diamonds(char) =5,
    Hearts(char) =6,
}
impl PokerCard{
    fn discriminant(&self) -> u8 {
        unsafe { *(self as *const Self as *const u8) }
    }
}
fn main(){
    unsafe{
        let f:extern "rust-call" fn((u8,)) -> PokerCard=core::mem::transmute(PokerCard::Spades as usize);
        let r = f((77u8,));
        assert_eq!(PokerCard::Spades(77),r);
        assert_eq!(7,r.discriminant());
    }
}

stable 和 nightly 的输出结果还不一样，我本地 nightly 的结果也不一样。所以这种写法似乎是 undefined behavior。