86 lines
2.1 KiB
Plaintext
86 lines
2.1 KiB
Plaintext
---
|
|
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.
|