// Modern Ruby-style syntax
const NAME = "MinZ";
let greeting = "Hello from #{NAME}!";  // Ruby interpolation!

// Zero-cost functional programming
numbers.iter()
    .filter(|x| x > 5)
    .map(|x| x * 2)
    .forEach(|x| print(x));  // Compiles to optimal DJNZ loop!

// Compile-time execution (faster than zero-cost!)
@ctie
fun distance(x: u8, y: u8) -> u8 {
    return abs(x - y);
}
let d = distance(10, 3);  // Becomes: LD A, 7 (computed at compile-time!)

// hello.minz
const VERSION = 15;

fun main() -> void {
    let message = "Hello from MinZ v0.#{VERSION}!";
    @print(message);
}

// Zero-cost iterator chains
let result = [1, 2, 3, 4, 5]
    .iter()
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .sum();  // Compiles to tight DJNZ loop!

// Simple arrays become DB directives
let data: [u8; 5] = [10, 20, 30, 40, 50];
// Generates: DB 10, 20, 30, 40, 50

// Struct arrays with proper alignment
struct Player { x: u16, y: u16, health: u8 }
let players: [Player; 2] = [
    Player { x: 100, y: 200, health: 100 },
    Player { x: 300, y: 400, health: 75 }
];
// Generates:
//   DW 100, 200  ; x, y
//   DB 100       ; health
//   DW 300, 400  ; x, y  
//   DB 75        ; health

const USER = "Alice";
const SCORE = 9001;

fun show_status() -> void {
    @print("Player #{USER} scored #{SCORE} points!");
}

@ctie
fun fibonacci(n: u8) -> u8 {
    if n <= 1 { return n; }
    return fibonacci(n-1) + fibonacci(n-2);
}

let fib10 = fibonacci(10);  // Computed at compile-time!
// Generates: LD A, 55  (no runtime calculation!)

enum Result {
    Ok(value: u8),
    Error(code: u8)
}

case parse_input() {
    Ok(n) => process(n),
    Error(0) => @print("Invalid input"),
    Error(e) => @print("Error code: #{e}")
}

fun read_file?(path: *u8) -> *u8 ? Error {
    let file = open(path)?;  // Propagate errors with ?
    let data = file.read_all()?;
    file.close()?;
    return data;
}

fun main() -> void {
    let content = read_file?("data.txt") ?? "default";  // Default on error
}

@smc
fun draw_sprite(x: u8, y: u8, sprite: *u8) -> void {
    // This function rewrites its own code for 10x performance!
    // Parameters are patched directly into instructions
}