Enums

Enums in Mist serve as powerful algebraic data types (ADTs), maintaining the exact behavior and safety of Rust enums while using square brackets for tuple variant types and name Type for struct-like fields.

Basic Syntax

An enum can contain unit variants, tuple variants (with types in square brackets), or struct-like variants.

pub enum TaskState {
    Pending,
    InProgress,
    Completed,
    Failed {
        reason String,
        code i32,
    },
}

Variant Types

Mist supports all standard variant shapes:

enum OptionInt {
    None,                         // Unit
    Some[i32],                    // Tuple (square brackets)
}

enum Shape {
    Circle { radius i32 },        // Struct-like
    Rect { w i32, h i32 },
}

Instantiation & Matching

Tuple variants are created with parentheses and matched with brackets:

let x = OptionInt::Some(42);

match (x) {
    OptionInt::None => { println!("none"); }
    OptionInt::Some[v] => { println!("{}", v); }
}

Struct variants use brace notation:

let c = Shape::Circle { radius: 5 };

match (c) {
    Shape::Circle { radius } => { println!("{}", radius); }
    Shape::Rect { .. } => { /* ignore */ }
}

Generics & Lifetimes

Enums declare generics and lifetimes in angle brackets after the name. Reference types use the * prefix.

pub enum Validation<'a, T> {
    Valid(T),
    Invalid {
        message *'a str,
        error_id u32,
    },
}

Key Characteristics

• Consistent Declaration: Struct-like variants use the name Type order, consistent with Mist structs.
• Square Bracket Tuples: Tuple variant types use [] brackets, distinct from function calls.
• Rust-Native ADTs: Enums compile directly to Rust enums, allowing exhaustive pattern matching and zero-cost abstraction.
• Shared Visibility: The pub modifier at the enum level exports all variants.
• Comma-Separated Members: Fields within struct-like variants are separated by commas.