enum Option { None, Some(u8) }

fun unwrap_or(opt: Option, def: u8) -> u8 {
    return match opt {
        Some(val) => val,
        None      => def,
    }
}

fun safe_div(a: u8, b: u8) -> Option {
    if b == 0 { return None }
    return Some(a / b)
}

assert unwrap_or(safe_div(10, 3), 255) == 3

test_safe_div_ok:    LD A, 3  / RET     ; the entire safe_div + match + unwrap chain
test_unwrap_some:    LD A, 42 / RET     ; unwrap_or(Some(42), 0)
test_is_none:        LD A, 0  / RET     ; is_some(None)
test_unwrap_none:    LD A, 77 / RET     ; unwrap_or(None, 77)

fun filter_map_explicit(buf: u16, n: u8, threshold: u8) -> void {
    for x: u8 in buf[0..n] {
        let doubled: u8 = x * 2
        if doubled > threshold {
            process(doubled)
        }
    }
}

filter_map_explicit:
    LD B, C                    ; loop counter = n
    LD C, D                    ; threshold
.fe_head:
    LD A, B / AND A / RET Z    ; done?
.fe_body:
    LD D, (HL)                 ; load element
    LD A, D / ADD A, A         ; x * 2 (map)
    LD D, A
    LD A, C / CP D             ; threshold vs doubled (filter)
    CALL C, process            ; conditional CALL -- fires only when filter passes
.fe_cont:
    INC HL                     ; advance pointer
    ...DEC B / JRS .fe_head    ; next element

let double (x : u8) : u8 = x + x
let inc    (x : u8) : u8 = x + 1

let pipe_dbl_inc (x : u8) : u8 = x |> double |> inc

pipe_dbl_inc:
    ADD A, A     ; double
    INC A        ; inc
    RET

struct Rect { kind: u8, w: u8, h: u8 }
trait Shape { area, perimeter }

impl Shape for Rect {
    fun area(self) -> u8 { return self.w * self.h }
    fun perimeter(self) -> u8 { return (self.w + self.h) * 2 }
}

Rect_area:
    EX DE, HL              ; save self ptr
    LD BC, 2 / ADD HL, BC  ; &self.w
    LD B, (HL)             ; w
    LD H, D / LD L, E
    LD BC, 3 / ADD HL, BC  ; &self.h
    LD E, (HL)             ; h
    LD A, B / LD B, E
    JP __mul8              ; tail call: w * h, return in A

Rect_perimeter:
    ...
    LD A, (HL) / RLA       ; w * 2 (rotate left = shift left 1)
    ...
    LD A, (HL) / RLA       ; h * 2
    ADD A, C               ; w*2 + h*2
    RET

fun fib_tail(n: u8, a: u8, b: u8) -> u8 {
    if n == 0 { return a }
    return fib_tail(n - 1, b, a + b)
}

assert fib_tail(10, 0, 1) == 55

fib_tail:
    AND A / RET Z          ; n == 0? return a (in B)
    DEC A                  ; n - 1
    LD A, B / ADD A, C     ; a + b
    LD B, A                ; new accumulator
    ...JRS fib_tail        ; jump, not CALL -- O(1) stack

fun *(a: u8, b: u8) -> u16 { ... }   // widening multiply

assert sat_add(200, 100) == 255       // saturates at u8 max
assert abs_diff(200, 50) == 150       // |a - b|
assert brightness_blend(100, 200, 128) == 150  // linear interpolation

struct Vec3 { x: i16, y: i16, z: i16 }

fun scene(p: Vec3) -> i16 {
    let sphere: i16 = sdf_sphere(p, 150)
    let box: i16 = sdf_box(p, Vec3{x: 100, y: 100, z: 100})
    return sdf_subtract(sphere, box)    // CSG: sphere minus box
}

fun set_ptr_bit() -> u8 {
    var p: ptr = &flags_g
    p^.4 = 1              // set bit 4 via pointer
    return p^.4            // read bit 4 back
}

fun minmax(a: u16, b: u16) -> (u16, u16) {
    if a <= b { return (a, b) }
    return (b, a)
}

let (lo, hi) = minmax(x, y)
let (first, _, last) = stats3(x, y, z)   // blank identifier skips middle value

fun xor_pixel(x: u8, y: u8) -> void {
    let addr: u16 = 0x4000 + y7*2048 + y2_0*256 + y5_3*32 + xbyte
    let p: ^u8 = addr
    p^ = p^ xor mask        // flip pixel via pointer XOR
}

let sierpinski (x : u8) (y : u8) = if (x & y) == 0 then 1 else 0
let xor_texture (x : u8) (y : u8) = x ^ y
let checker (x : u8) (y : u8) = ((x / 8) + (y / 8)) & 1