iota-rs

A rust macro for other Go refuges who miss const blocks and iota.

Go:

const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Partyday
    numberOfDays  // this constant is not exported
)

Rust:

#![feature(plugin)]
#![plugin(iota)]

consts!{
    pub SUNDAY: i32 = iota!();
    pub MONDAY;
    pub TUESDAY;
    pub WEDNESDAY;
    pub THURSDAY;
    pub FRIDAY;
    pub PARTYDAY;
    NUMBER_OF_DAYS;  // this constant is not exported
}

Like in Go, you can do multiple constants on a single line, and use underscore to skip values.

Go:

const (
    bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0
    bit1, mask1                           // bit1 == 2, mask1 == 1
    _, _                                  // skips iota == 2
    Bit3, Mask3                           // bit3 == 8, mask3 == 7
)

Rust:

#![feature(plugin)]
#![plugin(iota)]

consts!{
    (BIT0, MASK0): (i32, i32) = (1 << iota!(), 1<<iota!() - 1);  // bit0 == 1, mask0 == 0
    (BIT1, MASK1);                                               // bit1 == 2, mask1 == 1
    (_, _);                                                      // skips iota == 2
    (pub BIT3, pub MASK3);                                       // bit3 == 8, mask3 == 7
}

Rust sans-plugin:

// bit0 == 1, mask0 == 0
const BIT0: i32 = 1 << 0;
const MASK0: i32 = 1<<0 - 1;

// bit1 == 2, mask1 == 1
const BIT1: i32 = 1 << 1;
const MASK1: i32 = 1<<1 - 1;

// bit3 == 8, mask3 == 7
pub const BIT3: i32 = 1 << 3;
pub const MASK3: i32 = 1<<1 - 3;

As you can see, compared to the base langauge, this plugin makes it easy to create a large number of similar numerical constants without a bunch of error-prone copy-pasting or having to define your own short-term use macros.

For those coming from Go, you may have noticed some differences:

• Rust prefers ALL_CAPS constants, and does not base visibility on capitalization, so exported constants must be marked as "pub".
• Rust constants must be explicitly typed.
• iota is not a reserved keyword, but a macro invocation.
• Rust multiple assignment uses a more tuple like structure.