Create an array with enum element size - arrays

Question

I want to create an array of a size specified by an element in an enum, like so:
pub use self::Register::*;
enum Register {
Ip,
Sp,
NumRegs,
}
struct State {
val: int,
regs: [int; NumRegs as int],
running: bool,
}
But I get:
src/main.rs:19:11: 19:32 error: expected constant expr for array length: non-constant path in constant expr
src/main.rs:19 regs: [int; NumRegs as int],
I've tried using as int, among other solutions, and Googled around for some time, but have not found a solution. Incidentally, is this bad form in Rust?

Answer 1

Currently, I don't think Rust is capable of seeing that Enum::Variant is effectively a constant (I don't actually know that it is, either), so it cannot be used as the array length. More than that, I would say that it's strange to add an enum variant that isn't actually intended to be used.
For how I see your problem, I'd probably try to represent your registers as a struct:
struct Registers {
ip: u8,
sp: u8,
}
struct State {
val: u8,
regs: Registers,
running: bool,
}
fn main() {
let s = State {
val: 0,
regs: Registers { ip: 0, sp: 0 },
running: false,
};
}
Edit
If you'd like to get a register by name, how about we do that directly:
struct Registers {
ip: u8,
sp: u8,
}
impl Registers {
fn by_name(&self, name: &str) -> u8 {
match name {
"ip" => self.ip,
"sp" => self.sp,
_ => panic!("Unknown register '{}'", name),
}
}
fn by_name_mut(&mut self, name: &str) -> &mut u8 {
match name {
"ip" => &mut self.ip,
"sp" => &mut self.sp,
_ => panic!("Unknown register '{}'", name),
}
}
}
fn main() {
let mut r = Registers { ip: 0, sp: 0 };
println!("Instruction pointer: 0x{:02x}", r.by_name("ip"));
*r.by_name_mut("ip") += 1;
println!("Instruction pointer: 0x{:02x}", r.by_name("ip"));
}
Although that panic! right there is pretty ugly... I'd rather use an enum for that purpose. Let's do both the enum and the string:
use std::str::FromStr;
#[derive(Debug,Copy,Clone,PartialEq)]
enum Register {
Ip,
Sp,
}
impl FromStr for Register {
type Err = ();
fn from_str(s: &str) -> Result<Self, ()> {
match s {
"ip" => Ok(Register::Ip),
"sp" => Ok(Register::Sp),
_ => Err(()),
}
}
}
struct Registers {
ip: u8,
sp: u8,
}
impl Registers {
fn by_name(&self, name: Register) -> u8 {
match name {
Register::Ip => self.ip,
Register::Sp => self.sp,
}
}
fn by_name_mut(&mut self, name: Register) -> &mut u8 {
match name {
Register::Ip => &mut self.ip,
Register::Sp => &mut self.sp,
}
}
}
fn main() {
let mut rs = Registers { ip: 0, sp: 0 };
let r: Register = "ip".parse().unwrap();
println!("Instruction pointer: 0x{:02x}", rs.by_name(r));
*rs.by_name_mut(r) += 1;
println!("Instruction pointer: 0x{:02x}", rs.by_name(r));
}
Now we have a nice clear separation between transitioning a string to our Register type, which means that only one part of our code has to deal with invalid register names (the call to unwrap).