feat(options): redesign option handling with var...else and or_default

Replace Rust-style option handling with cleaner naml API:

- Add `var x = opt else { ... }` syntax for unwrapping with early return
- Add `.or_default(value)` method for providing defaults
- Remove `.unwrap()` and `.unwrap_or()` methods
- Keep `.is_some()` and `.is_none()` for boolean checks

Also fix parser to support `::` path syntax for enum variants
(e.g., `UserRole::Admin` now parses correctly as PathExpr).

Changes:
- AST: Add else_block field to VarStmt
- Parser: Parse else block after var initializer, parse :: paths
- Type checker: Validate else clause, add or_default, remove unwrap
- Codegen: Generate match expression for var...else pattern

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mjm918

examples/simple.naml

@@ -34,14 +34,6 @@ interface Serializable {
     fn to_bytes() -> bytes;
 }
 
-// =============================================================================
-// Result and Option Types
-// =============================================================================
-
-enum Option<T> {
-    Some(T),
-    None
-}
 
 // =============================================================================
 // Error Types
@@ -151,10 +143,10 @@ pub struct PhoneNumber {
 
 pub fn (self: PhoneNumber) format() -> string {
     var base: string = "+" + self.country_code + " (" + self.area_code + ") " + self.number;
-    if (self.extension.is_some()) {
-        return base + " ext. " + self.extension.unwrap();
+    var ext: string = self.extension else {
+        return base;
     }
-    return base;
+    return base + " ext. " + ext;
 }
 
 enum UserStatus {
@@ -191,14 +183,9 @@ pub struct User implements Serializable {
 }
 
 pub fn (self: User) full_name() -> string {
-    var first: string = "";
-    var last: string = "";
-    if (self.first_name.is_some()) {
-        first = self.first_name.unwrap();
-    }
-    if (self.last_name.is_some()) {
-        last = self.last_name.unwrap();
-    }
+    var first: string = self.first_name.or_default("");
+    var last: string = self.last_name.or_default("");
+
     if (first == "" && last == "") {
         return self.username;
     }
@@ -232,7 +219,7 @@ pub fn (self: User) has_role(role: UserRole) -> bool {
 }
 
 pub fn (self: User) is_admin() -> bool {
-    return self.has_role(UserRole.Admin);
+    return self.has_role(UserRole::Admin);
 }
 
 pub fn (self: User) to_json() -> string {
@@ -272,7 +259,10 @@ pub fn (mut self: LinkedList<T>) add(item: T) {
         self.head = some(node);
         self.tail = some(node);
     } else {
-        self.tail.unwrap().next = some(node);
+        var tail_node: LinkedListNode<T> = self.tail else {
+            return;
+        }
+        tail_node.next = some(node);
         self.tail = some(node);
     }
     self.length = self.length + 1;
@@ -281,10 +271,13 @@ pub fn (mut self: LinkedList<T>) add(item: T) {
 pub fn (self: LinkedList<T>) contains(item: T) -> bool {
     var current: option<LinkedListNode<T>> = self.head;
     while (current.is_some()) {
-        if (current.unwrap().value == item) {
+        var node: LinkedListNode<T> = current else {
+            break;
+        }
+        if (node.value == item) {
             return true;
         }
-        current = current.unwrap().next;
+        current = node.next;
     }
     return false;
 }
@@ -293,20 +286,31 @@ pub fn (mut self: LinkedList<T>) remove(item: T) -> bool {
     if (self.head.is_none()) {
         return false;
     }
-    if (self.head.unwrap().value == item) {
-        self.head = self.head.unwrap().next;
+    var head_node: LinkedListNode<T> = self.head else {
+        return false;
+    }
+    if (head_node.value == item) {
+        self.head = head_node.next;
         self.length = self.length - 1;
         return true;
     }
     var current: option<LinkedListNode<T>> = self.head;
-    while (current.unwrap().next.is_some()) {
-        if (current.unwrap().next.unwrap().value == item) {
-            var node: LinkedListNode<T> = current.unwrap();
-            node.next = current.unwrap().next.unwrap().next;
+    while (current.is_some()) {
+        var curr_node: LinkedListNode<T> = current else {
+            break;
+        }
+        if (curr_node.next.is_none()) {
+            break;
+        }
+        var next_node: LinkedListNode<T> = curr_node.next else {
+            break;
+        }
+        if (next_node.value == item) {
+            curr_node.next = next_node.next;
             self.length = self.length - 1;
             return true;
         }
-        current = current.unwrap().next;
+        current = curr_node.next;
     }
     return false;
 }
@@ -332,10 +336,16 @@ pub fn (self: TreeNode<T>) balance_factor() -> int {
     var left_height: int = 0;
     var right_height: int = 0;
     if (self.left.is_some()) {
-        left_height = self.left.unwrap().height;
+        var left_node: TreeNode<T> = self.left else {
+            return 0;
+        }
+        left_height = left_node.height;
     }
     if (self.right.is_some()) {
-        right_height = self.right.unwrap().height;
+        var right_node: TreeNode<T> = self.right else {
+            return left_height;
+        }
+        right_height = right_node.height;
     }
     return left_height - right_height;
 }
@@ -350,7 +360,10 @@ pub fn (mut self: BinarySearchTree<T>) insert(value: T) {
     if (self.root.is_none()) {
         self.root = some(node);
     } else {
-        self.insert_recursive(self.root.unwrap(), value);
+        var root_node: TreeNode<T> = self.root else {
+            return;
+        }
+        self.insert_recursive(root_node, value);
     }
     self.size = self.size + 1;
 }
@@ -359,7 +372,10 @@ fn (self: BinarySearchTree<T>) insert_recursive(current: TreeNode<T>, value: T)
     if (current.left.is_none()) {
         current.left = some(TreeNode { value: value, left: none, right: none, height: 1 });
     } else {
-        self.insert_recursive(current.left.unwrap(), value);
+        var left_node: TreeNode<T> = current.left else {
+            return;
+        }
+        self.insert_recursive(left_node, value);
     }
     self.update_height(current);
 }
@@ -368,10 +384,16 @@ fn (self: BinarySearchTree<T>) update_height(node: TreeNode<T>) {
     var left_height: int = 0;
     var right_height: int = 0;
     if (node.left.is_some()) {
-        left_height = node.left.unwrap().height;
+        var left_node: TreeNode<T> = node.left else {
+            return;
+        }
+        left_height = left_node.height;
     }
     if (node.right.is_some()) {
-        right_height = node.right.unwrap().height;
+        var right_node: TreeNode<T> = node.right else {
+            return;
+        }
+        right_height = right_node.height;
     }
     if (left_height > right_height) {
         node.height = left_height + 1;
@@ -388,7 +410,10 @@ fn (self: BinarySearchTree<T>) find_recursive(current: option<TreeNode<T>>, valu
     if (current.is_none()) {
         return none;
     }
-    return self.find_recursive(current.unwrap().left, value);
+    var node: TreeNode<T> = current else {
+        return none;
+    }
+    return self.find_recursive(node.left, value);
 }
 
 // =============================================================================
@@ -603,13 +628,15 @@ pub async fn (self: UserRepository) delete(id: UserId) -> bool throws DatabaseEr
 pub async fn (self: UserRepository) exists(id: UserId) -> bool throws DatabaseError {
     var query: string = "SELECT COUNT(*) FROM " + self.table_name + " WHERE id = ?";
     var result: [map<string, string>] = await self.execute_query(query, [id.value]);
-    return result[0]["count"].unwrap() > "0";
+    var count_str: string = result[0]["count"].or_default("0");
+    return count_str > "0";
 }
 
 pub async fn (self: UserRepository) count() -> int throws DatabaseError {
     var query: string = "SELECT COUNT(*) as cnt FROM " + self.table_name;
     var result: [map<string, string>] = await self.execute_query(query, []);
-    return result[0]["cnt"].unwrap() as int;
+    var cnt_str: string = result[0]["cnt"].or_default("0");
+    return cnt_str as int;
 }
 
 async fn (self: UserRepository) execute_query(query: string, params: [string]) -> [map<string, string>] throws DatabaseError {
@@ -621,17 +648,19 @@ async fn (self: UserRepository) execute_update(query: string, params: [string])
 }
 
 fn (self: UserRepository) map_row_to_user(row: map<string, string>) -> User {
+    var id_str: string = row["id"].or_default("");
+    var username_str: string = row["username"].or_default("");
     return User {
-        id: UserId { value: row["id"].unwrap() },
+        id: UserId { value: id_str },
         email: Email { local: "user", domain: "example.com" },
-        username: row["username"].unwrap(),
+        username: username_str,
         password_hash: "",
         first_name: none,
         last_name: none,
         address: none,
         phone: none,
         status: UserStatus.Active,
-        roles: [UserRole.User],
+        roles: [UserRole::User],
         metadata: {},
         created_at: 0,
         updated_at: 0,
@@ -881,17 +910,17 @@ async fn main() {
 
     var user_id: UserId = UserId { value: "user-123" };
 
-    var user: option<User> = await user_repo.find_by_id(user_id);
+    var user_opt: option<User> = await user_repo.find_by_id(user_id);
 
-    if (user.is_some()) {
-        printf("Found user: {}", user.unwrap().full_name());
-
-        var response: HttpResponse = await client.get("/users/" + user_id.value);
-        if (response.is_success()) {
-            printf("API call successful: {} {}", response.status_code, response.status_text);
-        }
-    } else {
+    var user: User = user_opt else {
         printf("User not found");
+        return;
+    }
+    printf("Found user: {}", user.full_name());
+
+    var response: HttpResponse = await client.get("/users/" + user_id.value);
+    if (response.is_success()) {
+        printf("API call successful: {} {}", response.status_code, response.status_text);
     }
 
     var numbers: [int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -943,4 +972,4 @@ async fn main() {
         var response: HttpResponse = await task;
         printf("Task completed: {}", response.status_code);
     }
-}
+}