# Enums: plain and tagged ## Plain enums A plain enum is a C-like set of named constants. It lowers to `i32` and is `Copy`: ```cplus enum Color { Red, Green, Blue } let c = Color::Red; ``` ## Tagged enums (sum types) A tagged enum carries data with each variant. This is how C+ models "one of several shapes", and it is the foundation of [error handling](/docs/error-handling): ```cplus enum Shape { Circle(f64), Rectangle(f64, f64), Square(f64), } let s = Shape::Circle(3.14); ``` ## Generic enums Enums can be generic over a type parameter, written with `[T]` (not ``): ```cplus enum Maybe[T] { Some(T), None, } let m: Maybe[i32] = Maybe[i32]::Some(7); let n: Maybe[i32] = Maybe[i32]::None; ``` **Always write the type arguments at the source level**: `Option[i32]::Some(v)`, `Option[i32]::None`. Internal mangled names like `Option__i32` exist but are never something you type. You consume an enum by [pattern matching](/docs/pattern-matching) on its variants. `==` / `!=` on a **payload-carrying** enum is **E0302** ("match on the variants instead"). The comparison previously escaped type-check and died as invalid LLVM IR. Payload-free enums still compare by discriminant. ## FFI enums: explicit discriminants and `#[repr]` A payload-free enum may take C-style values and an integer representation. That is what it lowers to and what it crosses the C ABI as. ```cplus #[repr(u8)] enum Mode { Off = 0, Slow = 10, Fast = 200 } enum Status { Ok, NotFound = 404, Gone } // Gone = 405 (prev + 1) ``` Discriminants are any constant expression (they fold). Unspecified values are `prev + 1`. `#[repr(C)]` is `i32`. Casts read the declared value; `match` switches on it. Wrong shapes are **E0923**: a payload enum with values or an integer repr, an out-of-range value, or a duplicate value.