生锈枚举中的原始类型

Question

In Rust it seems it is possible to define a Enum with primitive types as representations:

enum A {
    f64,
    i32
}

How can I use such an enum? For example, how would I create an instance and how would I use a match statement to handle different primitive types?

Answer 1

(This answer is as of 0.9)

That isn't doing quite what you think it is doing. It's creating an enum A with variants named f64 and i32 , not using those types. Since types and everything else (variables etc) share different namespaces, you might not notice. An example of using the original enum:

enum A {
    f64,
    i32
}

fn main() {
   let x: A = f64;
   let y: A = i32;

   match x {
       f64 => println!("got f64"),
       i32 => println!("got i32")
   }
}

To actually wrap values of those types, you need to use "tuple-like variants":

enum A {
    Float(f64),
    Int(i32)
}

fn main() {
    let x: A = Float(42.0);
    let y: A = Int(7);

    match x {
        Float(value) => println!("got Float({})", value),
        Int(value) => println!("got Int({})", value)
    }
}

Answer 2

You're not doing what you expect, check the output of this:

enum A {
    f64,
    i32
}

fn main() {
    let x:A = f64;
    let y:A = i32;
    println!("{}, {}", x as int, y as int);
}

f64 and i32 as just variants of the enum, just like any other name for a constant. This way, it's working more like C enums than C unions.