Updated docs to 0.3.1

content/docs/components/enums.mdx

@@ -1,57 +1,85 @@
 ---
 title: Enums
-description: Defining algebraic data types with Mist's type-first convention.
+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 applying the language-wide `type name` convention for variants that contain data.
+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, or struct-like variants. Following Mist's core philosophy, struct-like variants place the type before the identifier.
+An enum can contain unit variants, tuple variants (with types in square brackets), or struct-like variants.
 
 ```mist
 pub enum TaskState {
     Pending,
     InProgress,
     Completed,
-    // Struct-like variant using 'type name'
     Failed {
-        String reason,
-        i32 code,
+        reason String,
+        code i32,
     },
 }
 ```
+
 ## Variant Types
 
-Mist supports all standard variant shapes, ensuring a 1:1 mapping to the underlying Rust execution model.
+Mist supports all standard variant shapes:
 
 ```mist
-enum Message {
-    Quit,                          // Unit
-    Move(i32, i32),                // Tuple
-    Write(String),                 // Tuple
-    ChangeColor {                  // Struct-like
-        u8 r, u8 g, u8 b,
-    },
+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
 
-Just like structs and functions, enums declare generics and lifetimes in a unified block. This is particularly useful for defining custom Result or Option types that handle references.
+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 {
-        str'a* message,
-        u32 error_id,
+        message *'a str,
+        error_id u32,
     },
 }
 ```
+
 ## Key Characteristics
 
-- **Consistent Member Declaration**: Struct-like variants maintain the `type name` order, ensuring that data modeling feels identical whether you are defining a top-level `struct` or an `enum` variant.
-- **Rust-Native ADTs**: Enums compile directly to Rust enums, allowing for exhaustive pattern matching and zero-cost abstraction.
-- **Shared Visibility**: The `pub` modifier at the enum level exports all variants for use in other modules, matching Rust's visibility rules for enums.
-- **Comma-Separated Members**: Fields within struct-like variants are separated by commas, mirroring the syntax used in standard Mist structs.
+- **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.