---
title: Enums
description: Defining algebraic data types with Mist's data-first convention.
icon: Layers
---

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.

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

## Variant Types

Mist supports all standard variant shapes:

```mist
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:

```mist
let x = OptionInt::Some(42);

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

Struct variants use brace notation:

```mist
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.

```mist
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.