int      // 64-bit signed integer
float    // 64-bit IEEE-754
bool     // true | false
char     // Unicode code point
string   // UTF-8 sequence

// Integer conversions
auto x = 42
auto x_float = x.to_float()     // int -> float
auto x_str = x.to_string()      // int -> str
auto x_same = x.to_int()        // int -> int (identity)

// Float conversions
auto pi = 3.14
auto pi_int = pi.to_int()       // float -> int (truncates: 3)
auto pi_str = pi.to_string()    // float -> str
auto pi_same = pi.to_float()    // float -> float (identity)

// Boolean conversions
auto flag = true
auto flag_int = flag.to_int()   // bool -> int (true=1, false=0)
auto flag_float = flag.to_float() // bool -> float (true=1.0, false=0.0)
auto flag_str = flag.to_string() // bool -> string ("true" or "false")

// Char conversions
auto ch = 'A'
auto ch_str = ch.to_string()    // char -> str

// Method calls on literals require parentheses
auto num = (3).to_string()      // Valid
auto val = (42).to_float()      // Valid
// auto bad = 3.to_string()     // ERROR: parsed as float 3.0

// String to number (returns result)
auto num_str = "42"
auto result = num_str.to_int()
match result {
    ok(value) {
        print("Parsed: " + value.to_string())  // "Parsed: 42"
    }
    err(error) {
        print("Parse error: " + error)
    }
}

// String to float
auto float_str = "3.14159"
auto float_result = float_str.to_float()
match float_result {
    ok(value) { print(value.to_string()) }
    err(msg) { print("Error: " + msg) }
}

// Char to digit (only works for '0'-'9')
auto digit_char = '5'
auto digit_result = digit_char.to_int()
match digit_result {
    ok(digit) { print(digit.to_string()) }  // "5"
    err(msg) { print(msg) }
}

auto letter = 'A'
auto letter_result = letter.to_int()
match letter_result {
    ok(_) { print("Unexpected success") }
    err(msg) { print(msg) }  // "Character is not a digit (0-9)"
}

// Type mismatches in binary operations
auto bad1 = 1 + 1.0        // ERROR: cannot add int and float
auto bad2 = "hello" + 3    // ERROR: cannot add string and int
auto bad3 = true + false   // ERROR: cannot add bool and bool

// Type mismatches in comparisons
auto bad4 = 1 < 1.0        // ERROR: cannot compare int and float
auto bad5 = "a" == 1       // ERROR: cannot compare string and int

// Function argument type mismatches
func takes_string(string s) returns void { }
takes_string(123)          // ERROR: expected string, got int
// Correct usage requires explicit conversion
auto good1 = 1 + (1.0).to_int()           // OK: 2
auto good2 = "hello" + (3).to_string()    // OK: "hello3"
auto good3 = 1.to_float() < 1.0           // OK: true
auto good4 = (true).to_int() + (false).to_int()  // OK: 1

// Generate indices for iteration
for i in range(0, 5) {
    print(i.to_string())  // Prints 0, 1, 2, 3, 4
}

// Create a list of numbers
auto numbers = range(10, 15)  // [10, 11, 12, 13, 14]

print("Enter your name: ")
auto name = read_line()
print("Hello, " + name)

optional<T>
result<T, E>
list<T>
map<K,V>
set<T>
tuple<T, U>

### 3.4.1 Tuples

Tuples are fixed size pairs. A tuple always has exactly two elements.

```mux
auto pair = (1, "one")
tuple<int, string> typed = (2, "two")

print(pair.left.to_string())   // "1"
print(pair.right.to_string())  // "one"

auto empty = tuple<int, string>.new()  // (0, "")

### 3.5 Generics

Mux supports Go/Rust-style generics with type parameters and interface bounds using the `is` keyword:

```mux
// Generic function with type constraints
func max<T is Comparable>(T a, T b) returns T {
    if a > b {
        return a
    }
    return b
}

// Generic function with Stringable bound for to_string()
func greet<T is Stringable>(T value) returns string {
    return "Hello, " + value.to_string()
}

// Arithmetic operators are builtin for primitive numeric types.
// Use explicit methods or domain-specific APIs for generic composition.

// Generic class
class Stack<T> {
    list<T> items
    
    func push(T item) returns void {
        self.items.push_back(item)
    }
    
    func pop() returns optional<T> {
        if self.items.is_empty() { return none }
        return self.items.pop_back()
    }
}

func identity<T>(T value) returns T {
    return value
}

auto a = identity(42)        // Generates: identity$int
auto b = identity("hello")   // Generates: identity$string

interface Equatable {
    func eq(Self) returns bool
}

class Point is Equatable {
    int x
    int y
    
    func eq(Point other) returns bool {
        return self.x == other.x && self.y == other.y
    }
}
    }
}

auto p1 = Point.new(1, 2)
auto p2 = Point.new(1, 2)
auto same = p1 == p2  // true

// Using built-in interfaces
func process<T is Stringable>(list<T> items) returns void {
    for item in items {
        print(item.to_string())
    }
}

// Multiple bounds (AND semantics - type must implement all)
func combine<T is Comparable & Stringable>(T a, T b) returns string {
    if a < b {
        return a.to_string() + " < " + b.to_string()
    }
    return a.to_string() + " >= " + b.to_string()
}

// Type parameters must be explicitly specified
auto max_int = max<int>(3, 7)           // T = int, Comparable bound satisfied
auto names = ["apple", "banana"]
print(greet<string>(names[0]))          // T = string, Stringable bound satisfied

const int MAX = 100

// Variables (explicit type required for declarations without inference)
int x = 5
bool flag = true
string name = "MuxLang"

// Type inferred with 'auto'
auto x = 42          // inferred as int
auto pi = 3.14159    // inferred as float
auto name = "Mux"    // inferred as str

// Explicit type annotation
int count = 0
list<string> names = []
map<string, string | int> user = {"name": "Alice", "age": 30}

// Valid inference
auto value = someFunction()
auto numbers = [1, 2, 3]
map<string, string> userMap = {"key": "value"}

// Invalid - no initializer with 'auto'
auto x  // ERROR: cannot infer type without initializer

// Function parameters must be explicitly typed
func process(auto item) returns void { }  // ERROR
func process(int item) returns void { }   // Valid

// Unused parameter
func process(int item, int _) returns void { }  // second parameter unused

// Function-level constants
func calculate() returns int {
    const int MULTIPLIER = 10
    const float TAX_RATE = 0.08
    int value = 100
    return value * MULTIPLIER
}

// Constants in classes
class Config {
    const int MAX_RETRIES
    int current_retry
    
    func increment() returns void {
        self.current_retry++  // OK - mutable field
        // self.MAX_RETRIES++  // ERROR: Cannot modify const field 'MAX_RETRIES'
    }
}

auto cfg = Config.new()
cfg.current_retry = 1  // OK - mutable field
// cfg.MAX_RETRIES = 5  // ERROR: Cannot assign to const field 'MAX_RETRIES'

func add(int a, int b) returns int {
    return a + b
}

func greet(string name, int times = 1) returns void {
    for i in range(0, times) {
        print("Hello, " + name)
    }
}

func processData() returns map<string, int> {
    map<string, int> results = {"processed": 100, "skipped": 5}
    auto total = results["processed"] + results["skipped"]
    results["total"] = total
    return results
}

// Function with unused parameters
func callback(string event, int timestamp, string _) returns void {
    print("Event: " + event + " at " + timestamp)
    // third parameter ignored
}

auto squared = 5 ** 2        // 25
auto cubed = 2.0 ** 3.0      // 8.0
auto complex = 2 ** 3 ** 2   // 512 (right-associative)

auto counter = 0
counter++         // Valid: counter is now 1
counter--         // Valid: counter is now 0

// INVALID - cannot use in expressions:
// auto x = counter++    // ERROR: ++ cannot be used in expressions
// auto y = (counter++) + 5  // ERROR: standalone only

// INVALID - prefix not supported:
// ++counter            // ERROR: prefix increment not supported

// INVALID - cannot modify const:
const int MAX = 100
// MAX++               // ERROR: cannot modify const

// List containment
auto nums = [1, 2, 3, 4, 5]
auto hasThree = 3 in nums     // true
auto hasTen = 10 in nums      // false

// Set containment
auto tags = {"urgent", "important"}
auto isUrgent = "urgent" in tags    // true

// String containment
auto msg = "hello world"
auto hasWorld = "world" in msg      // true
auto hasFoo = "foo" in msg          // false

// Character in string
auto hasO = 'o' in msg              // true
auto hasZ = 'z' in msg              // false

// INVALID - type mismatch:
// auto bad = "1" in nums           // ERROR: string not in list<int>
// auto bad2 = 1 in msg             // ERROR: int not in string

// List concatenation
auto list1 = [1, 2]
auto list2 = [3, 4]
auto combined = list1 + list2    // [1, 2, 3, 4]

// Map merge (latter wins on key collision)
auto map1 = {"a": 1, "b": 2}
auto map2 = {"b": 3, "c": 4}     // Note: key "b" exists in both
auto merged = map1 + map2        // {"a": 1, "b": 3, "c": 4}

// Set union
auto set1 = {1, 2, 3}
auto set2 = {3, 4, 5}
auto unioned = set1 + set2       // {1, 2, 3, 4, 5}

// String concatenation
auto greeting = "Hello, " + "World"  // "Hello, World"

// INVALID - type mismatch:
// auto bad = [1, 2] + {3, 4}       // ERROR: cannot add list and set
// auto bad2 = [1, 2] + [3.0, 4.0]  // ERROR: list<int> + list<float>

// Block-form lambda with explicit types and return type
auto square = func(int n) returns int {
    return n * n
}

auto doubler = func(float x) returns float {
    return x * 2.0
}

// Passing lambdas to functions
auto result = apply(10, func(int x) returns int {
    return x + 5
})

// Lambda with unused parameters
auto processFirst = func(int first, int _) returns int {
    return first * 2  // second parameter ignored
}

// Block-form lambda with mixed explicit/inferred types
auto filter = func(list<int> nums, func(int) returns bool cond) returns list<int> {
    list<int> out = []
    for n in nums {
        if cond(n) {
            out.push_back(n)
        }
    }
    return out
}

if x > 0 {
    print("positive")
} else if x < 0 {
    print("negative")
} else {
    print("zero")
}

// With type inference
auto message = if x > 0 { "positive" } else { "non-positive" }

match (value) {
    some(v) if v > 10 {
        auto msg = "large: " + v  // local inference
        print(msg)
    }
    some(v) {
        print("small: " + v)
    }
    none {
        print("no value")
    }
    _ {
        print("unexpected case")  // wildcard pattern
    }
}

// Match on int literals (like a switch)
auto status = 200
match status {
    200 { print("OK") }
    404 { print("Not Found") }
    500 { print("Server Error") }
    _ { print("Unknown status") }
}

// Match on string literals
auto command = "start"
match command {
    "start" { print("Starting...") }
    "stop" { print("Stopping...") }
    "restart" { print("Restarting...") }
    _ { print("Unknown command") }
}

// Variable binding in patterns
auto value = 42
match value {
    1 { print("one") }
    captured { print("got: " + captured.to_string()) }
    _ { print("other") }
}

// List literal matching
auto nums = [1, 2, 3]
match nums {
    [] { print("empty") }
    [1, 2, 3] { print("three elements") }
    [first, ..rest] { print("has elements") }
}

// Switch with guards
auto score = 85
match score {
    n if n >= 90 { print("A") }
    n if n >= 80 { print("B") }
    n if n >= 70 { print("C") }
    n if n >= 60 { print("D") }
    _ { print("F") }
}

for item in myList {
    auto processed = transform(item)  // type inferred
    print(processed)
}

// Iterator with inference
for item in collection {
    // item type inferred from collection element type
    process(item)
}

// Ignoring loop variables when not needed
for _ in range(0, 10) {
    doSomething()  // don't care about the index
}

// Destructuring in loops with unused parts
for (key, _) in keyValuePairs {
    print("Key: " + key)  // value ignored
}

while cond {
    auto currentTime = getCurrentTime()  // local inference
    // ...
}

enum Shape {
    Circle(float radius)
    Rectangle(float width, float height)
    Square(float size)
}

enum Shape {
    Circle(float radius)
    Rectangle(float width, float height)
    Square(float size)
}

// Usage with inference
auto myShape = Circle.new(5.0)  // type inferred as Shape
list<Shape> shapes = [Circle.new(1.0), Rectangle.new(2.0, 3.0)]

// Pattern matching with unused enum data
match (shape) {
    Circle(_) {
        print("It's a circle")  // radius value ignored
    }
    Rectangle(width, _) {
        print("Rectangle with width: " + width)  // height ignored
    }
    Square(size) {
        print("Square with size: " + size)
    }
}

interface Drawable {
    func draw() returns void
}

class Circle is Drawable, ShapeLike {
    float radius  // explicit type required for fields

    func draw() returns void {
        auto message = "Circle radius=" + radius  // local inference in methods
        print(message)
    }

    func area() returns float {
        const float PI = 3.1415  // inferred as float
        return PI * radius * radius
    }
    
    // Method with unused parameters
    func resize(float newRadius, string _) returns void {
        radius = newRadius  // second parameter ignored
    }
}

// Generic class example
class Stack<T> {
    list<T> items

    func push(T item) returns void {
        items.push_back(item)
    }

    func pop() returns optional<T> {
        if items.isEmpty() {
            return none
        }
        auto item = items.pop_back()
        return some(item)
    }
}

// Usage with inference
auto circle = Circle.new(5.0)  // type inferred as Circle
list<Drawable> shapes = [circle]
Stack<int> intStack = Stack<int>.new()  // explicit generic instantiation with .new()

class Stack<T> {
    list<T> items
    
    // Instance method - called on instances
    func push(T item) returns void {
        self.items.push_back(item)
    }
    
    // Static method - called on the class
    common func who_am_i() returns string {
        return "I'm a Stack!"
    }
    
    // Factory pattern - static method that creates instances
    common func from(list<T> init_list) returns Stack<T> {
        auto new_stack = Stack<T>.new()
        new_stack.items = init_list
        return new_stack
    }
}

// Calling static methods
print(Stack.who_am_i())                    // "I'm a Stack!"
auto s = Stack<int>.from([1, 2, 3])        // Factory method

// Calling instance methods
auto stack = Stack<int>.new()
stack.push(42)                             // Instance method

// Basic instantiation
auto circle = Circle.new()           // No constructor arguments
auto circle2 = Circle.new(5.0)       // With constructor arguments

// Generic class instantiation
auto int_stack = Stack<int>.new()
auto string_stack = Stack<string>.new()

// Using factory methods
auto prebuilt = Stack<int>.from([1, 2, 3])
auto pair = Pair<string, int>.from("key", 42)

class Circle {
    func draw() returns void { ... }
}

// Explicit typing
list<int> nums = [1, 2, 3, 4]
map<string, int> scores = {"Alice": 90, "Bob": 85}

// With type inference
auto nums = [1, 2, 3, 4]           // inferred as list<int>
map<string, int> scores = {"Alice": 90, "Bob": 85}
// mixed = [1, 2.5, 3]           // ERROR: conflicting types, explicit type needed

// Nested collections
list<list<int>> matrix = [[1, 2], [3, 4]]
map<string, list<int>> lookup = {"users": [1, 2, 3], "admins": [4, 5]}

// Complex nested structures
auto users = [
    {"name": "Alice", "scores": [95, 87, 92]},
    {"name": "Bob", "scores": [78, 85, 90]}
]  // inferred as list<map<string, string | list<int>>>

auto data = {
    "numbers": [1, 2, 3, 4, 5],
    "metadata": {"version": "1.0", "count": 5}
}  // inferred as map<string, list<int> | map<string, string | int>>

// Generic collections
list<Pair<int, string>> pairs = [Pair.new(1, "one"), Pair.new(2, "two")]
list<Container<int>> containers = list<Container<int>>()

auto nums = [1, 2, 3]

// Safe access with optional
match nums.get(0) {
    some(first) { print(first.to_string()) }  // "1"
    none { print("Index out of bounds") }
}

// Direct access (runtime error if index invalid)
auto second = nums[1]  // 2

// Mutation
nums.push_back(4)      // [1, 2, 3, 4]
match nums.pop_back() {
    some(last) { print(last.to_string()) }  // "4"
    none { }
}

// Inspection
print(nums.size().to_string())     // "3"
print(nums.is_empty().to_string())   // "false"

auto scores = {"Alice": 90, "Bob": 85}

// Safe access
match scores.get("Alice") {
    some(score) { print(score.to_string()) }  // "90"
    none { print("Student not found") }
}

// Direct access
auto bobScore = scores["Bob"]  // 85

// Map entries are immutable; reassign to update
scores["Alice"] = 95  // Updates existing key

auto tags = {"urgent", "important", "review"}
print(tags.size().to_string())  // "3"

// Add and check membership
tags.add("priority")
if tags.contains("urgent") {
    print("Has urgent tag")
}

// Remove item
match tags.remove("review") {
    some(removed) { print("Removed: " + removed) }
    none { print("Item not found") }
}

auto nested = [
    {"name": "Alice", "scores": [95, 87, 92]},
    {"name": "Bob", "scores": [78, 85, 90]}
]
// Structure: list<map<string, list<int> | string>>

func divide(int a, int b) returns result<int, string> {
    if b == 0 {
        return err("division by zero")
    }
    return ok(a / b)
}

// Usage with inference
auto result = divide(10, 2)  // inferred as result<int, string>
match result {
    ok(value) {
        auto message = "result: " + value  // local inference
        print(message)
    }
    err(error) {
        print("Error: " + error)
    }
    _ {
        print("Unexpected result")  // wildcard for completeness
    }
}

// Ignoring error details when not needed
match result {
    ok(value) {
        print("Success: " + value)
    }
    err(_) {
        print("some error occurred")  // error details ignored
    }
}

result<int, string> res1 = ok(42)
result<int, string> res2 = err("error")

print(res1.is_ok().to_string())   // true
print(res1.is_err().to_string())  // false
print(res2.is_ok().to_string())   // false
print(res2.is_err().to_string())  // true

func findEven(list<int> xs) returns optional<int> {
    for x in xs {
        if x % 2 == 0 {
            return some(x)
        }
    }
    return none
}

// Usage with inference
optional<int> maybeEven = findEven([1, 3, 4, 7])  // inferred as optional<int>

match maybeEven {
    some(value) {
        print("Found even: " + value)
    }
    none {
        print("No even number found")
    }
    _ {
        print("Unexpected optional state")
    }
}

// Ignoring the wrapped value when you just care about presence
match maybeEven {
    some(_) {
        print("Got a value")  // don't care what the value is
    }
    none {
        print("Got nothing")
    }
}

optional<int> opt1 = some(42)
optional<int> opt2 = none

print(opt1.is_some().to_string())  // true
print(opt1.is_none().to_string())  // false
print(opt2.is_some().to_string())  // false
print(opt2.is_none().to_string())  // true

auto opt = some(42)      // discriminant=1, data=box(42)
auto res = ok("error")   // discriminant=0, data=box("error")

┌──────────────────┬─────────────┐
│   RefHeader      │    Value    │
│ ref_count: u64   │  (payload)  │
└──────────────────┴─────────────┘
    ^
    Allocation pointer

// Basic reference usage
int x = 10
auto r = &x      // r is of type &int
print("ref value: " + (*r).to_string())  // 10 - explicit dereference with *

*r = 20          // Changes x to 20 via dereference
print("val after ref update: " + (*r).to_string())  // 20
print("x is now: " + x.to_string())  // 20

// References to list elements
auto numbers = [1, 2, 3, 4, 5]
auto first = &numbers[0]  // &int
print("first element: " + (*first).to_string())  // 1

// Function taking a reference
func update(&int ref) returns void {
    *ref = *ref + 1  // Must explicitly dereference to modify
}

update(&x)
print("val after update: " + x.to_string())  // 21

import math
import std.math
import shapes.circle as circle

// Usage with inference
float pi = math.PI         // type inferred from math module
float root = math.sqrt(9.0)
auto c = circle.new(5.0)  // type inferred from constructor

// Import with unused alias for completeness
import utils.logger as _  // imported but not directly used in this scope

import math          // math.mux in same directory
import shapes.circle // shapes/circle.mux
import std.math      // stdlib math module

// math.mux
func fibonacci(int n) returns int { ... }

// main.mux
import math
auto result = math.fibonacci(10)

// config.mux
const int MAX_USERS = 100
auto initialized = false

func init() returns void {
    initialized = true
}

// These require explicit types due to ambiguity
list<int> empty = []           // empty collection needs explicit type
auto empty = list<int>()       // or explicit constructor

result<int, string> pending    // uninitialized variables need explicit type

// Generic instantiation may need explicit types
Stack[int] stack = Stack[int]()      // explicit generic parameter
auto pairs = zip<int, string>(numbers, names)  // when inference is ambiguous

// Good uses of underscore
func process(int data, string _) { }  // ignore second parameter
for _ in range(0, 10) { }            // ignore loop counter
match result { ok(_) { } }           // ignore success value

// Avoid overusing underscore when names would help readability
// Less clear:
func calculate(int _, int _, float _) returns float { }

// Better:
func calculate(int width, int height, float _) returns float { }

import math

const float PI = 3.14159  // inferred as float

enum MaybeValue<T> { 
    some(T) 
    none 
}

interface Shape {
    func area() returns float
}

class Circle is Shape {
    float r  // explicit type required for fields
    
    func area() returns float { 
        return PI * r * r 
    }
}

// Generic utility function
func map<T, U>(list<T> items, func(T) returns U transform) returns list<U> {
    auto result = list<U>()
    for item in items {
        result.push_back(transform(item))
    }
    return result
}

func main() returns void {
    auto shapes = [Circle.new(2.0), Circle.new(3.5)]  // inferred as list<Circle>
    
    for shape in shapes {
        float area = shape.area()  // inferred as float
        string message = "Area: " + area  // inferred as str
        print(message)
    }
    
    // Working with Results and inference
    auto results = list<result<float, string>>()
    for shape in shapes {
        auto areaResult = ok(shape.area())  // inferred as result<float, string>
        results.push_back(areaResult)
    }
    
    // Using generics with inference and lambdas
    auto areas = map(shapes, func(Shape s) {
        return s.area()  // inferred as list<float>
    })
    
    auto descriptions = map(areas, func(string a) {
        return "Area: " + a  // inferred as list<string>
    })
    
    // Pattern matching with underscore
    for result in results {
        match result {
            ok(value) {
                print("Success: " + value)
            }
            err(_) {
                print("Error occurred")  // don't care about error details
            }
        }
    }
}

import std                    // use std.assert, std.math, std.io, std.random, std.datetime, std.sync, std.net, std.env, std.data, std.sql
import std.assert              // use assert.*
import std.math               // use math.*
import std.io                 // use io.*
import std.random             // use random.*
import std.datetime           // use datetime.*
import std.sync               // use sync.*
import std.net                // use net.*
import std.env                // use env.*
import std.data               // use data.*
import std.sql                // use sql.*
import std.(math, random as r)
import std.*                  // flat import of stdlib items

import std.dsa                       // use dsa.stack, dsa.queue, etc.
import std.dsa.stack                 // use stack.*
import std.dsa.algorithm             // use algorithm.*
import std.dsa.collection.Collection // import the interface

mux-lang/
├── mux-compiler/
│   ├── src/
│   │   ├── ast/
│   │   │   ├── types.rs
│   │   │   ├── nodes.rs
│   │   │   ├── literals.rs
│   │   │   ├── operators.rs
│   │   │   ├── patterns.rs
│   │   │   ├── error.rs
│   │   │   └── mod.rs
│   │   ├── codegen/
│   │   │   ├── mod.rs
│   │   │   ├── expressions.rs
│   │   │   ├── statements.rs
│   │   │   ├── functions.rs
│   │   │   ├── methods.rs
│   │   │   ├── classes.rs
│   │   │   ├── constructors.rs
│   │   │   ├── operators.rs
│   │   │   ├── generics.rs
│   │   │   ├── types.rs
│   │   │   ├── memory.rs
│   │   │   └── runtime.rs
│   │   ├── semantics/
│   │   │   ├── mod.rs
│   │   │   ├── types.rs
│   │   │   ├── symbol_table.rs
│   │   │   ├── unifier.rs
│   │   │   ├── format.rs
│   │   │   └── error.rs
│   │   ├── lexer/
│   │   │   ├── mod.rs
│   │   │   ├── token.rs
│   │   │   ├── span.rs
│   │   │   └── error.rs
│   │   ├── parser/
│   │   │   ├── mod.rs
│   │   │   └── error.rs
│   │   ├── diagnostic/
│   │   │   ├── mod.rs
│   │   │   ├── emitter.rs
│   │   │   ├── files.rs
│   │   │   └── styles.rs
│   │   ├── module_resolver.rs
│   │   ├── source.rs
│   │   ├── lib.rs
│   │   └── main.rs
│   └── tests/
│       ├── lexer_integration.rs
│       ├── parser_integration.rs
│       ├── semantics_integration.rs
│       ├── executable_integration.rs
│       └── snapshots/
│
├── mux-runtime/
│   ├── src/
│   │   ├── lib.rs
│   │   ├── object.rs
│   │   ├── refcount.rs
│   │   ├── boxing.rs
│   │   ├── bool.rs
│   │   ├── int.rs
│   │   ├── float.rs
│   │   ├── string.rs
│   │   ├── list.rs
│   │   ├── map.rs
│   │   ├── set.rs
│   │   ├── optional.rs
│   │   ├── result.rs
│   │   ├── io.rs
│   │   ├── math.rs
│   │   └── std.rs
│   └── Cargo.toml
│
├── test_scripts/
│   ├── error_cases/
│   │   ├── *.mux
│   └── *.mux
│
├── Cargo.toml
├── Cargo.lock
└── AGENTS.md