Milk Tea Reference

## A minimal Milk Tea program.
import std.stdio as io

function main() -> int:
    io.print_line("Hello, Milk Tea!")
    return 0

function main() -> int:
    return 0

mtc run hello.mt

## Milk Tea
function add(a: int, b: int) -> int:
    return a + b

struct Vec2:
    x: float
    y: float

extending Vec2:
    editable function scale(factor: float):
        this.x *= factor
        this.y *= factor

/* Generated C */
int main_add(int a, int b) {
    return a + b;
}

typedef struct { float x; float y; } main_Vec2;

void main_Vec2_scale(main_Vec2* this, float factor) {
    this->x *= factor;
    this->y *= factor;
}

## ── Imports ──────────────────────────────────────────────────────────
import std.stdio as io
import std.hash
import std.str
import std.vec
import std.map
import std.math
import std.mem.heap as heap
import std.fmt

## ── Constants ────────────────────────────────────────────────────────
const MAX_ENTITIES: int = 256
const GRAVITY: float = 9.81

## Block-bodied constant (computed at compile time)
const BUFFER_SIZE -> int:
    var n: int = 64
    while n < MAX_ENTITIES:
        n = n * 2
    return n

## const function: evaluable at compile time, also callable at runtime
const function square(x: int) -> int:
    return x * x

const TILE_AREA: int = square(16)

## ── Type Alias ───────────────────────────────────────────────────────
type EntityId = uint

## ── Enum (explicit backing type, exhaustive match) ───────────────────
enum EntityKind: ubyte
    player = 0
    enemy = 1
    npc = 2

## ── Flags (named bitmask with composite alias) ──────────────────────
flags StatusFlags: uint
    poisoned = 1 << 0
    stunned = 1 << 1
    shielded = 1 << 2
    debuffed = StatusFlags.poisoned | StatusFlags.stunned

## ── Struct with nested struct ────────────────────────────────────────
struct Entity:
    id: EntityId
    kind: EntityKind
    name: str
    hp: int
    max_hp: int
    position: vec3

    struct Stats:
        attack: int
        defense: int
        speed: float

    stats: Stats

## ── Variant (tagged union with payload arms) ────────────────────────
variant Action:
    move(dx: float, dy: float)
    attack(target_id: EntityId, damage: int)
    heal(amount: int)
    idle

## ── Interfaces (nominal contracts; dyn provides explicit dispatch) ───
public interface Damageable:
    editable function take_damage(amount: int) -> void
    function is_alive() -> bool

interface Named:
    function display_name() -> str

## ── Struct implementing multiple interfaces ─────────────────────────
struct Player implements Damageable, Named:
    entity: Entity
    score: int
    level: int

## ── User-defined attribute ──────────────────────────────────────────
attribute[field] column(name: str)

struct SaveData:
    @[column(name = "lvl")]
    level: int
    @[column(name = "pts")]
    score: int

## ── Opaque type (unknown C layout) ──────────────────────────────────
opaque NativeHandle

## ── Methods via extending ───────────────────────────────────────────
## function = value receiver, editable function = mutable, static = no receiver
extending Entity:
    function is_alive() -> bool:
        return this.hp > 0

    editable function apply_damage(amount: int) -> void:
        let actual = amount - this.stats.defense
        if actual > 0:
            this.hp -= actual
        if this.hp < 0:
            this.hp = 0

    static function create(id: EntityId, kind: EntityKind, name: str) -> Entity:
        return Entity(
            id = id,
            kind = kind,
            name = name,
            hp = 100,
            max_hp = 100,
            position = vec3(x = 0.0, y = 0.0, z = 0.0),
            stats = Entity.Stats(attack = 10, defense = 5, speed = 1.0),
        )

extending Player:
    editable function take_damage(amount: int) -> void:
        this.entity.apply_damage(amount)

    function is_alive() -> bool:
        return this.entity.is_alive()

    function display_name() -> str:
        return this.entity.name

    ## .with() returns a copy with specified fields replaced
    function with_score(new_score: int) -> Player:
        return this.with(score = new_score)

## ── Hash/equal hooks (enable use as Map/Set keys) ───────────────────
extending Entity.Stats:
    static function hash(value: const_ptr[Entity.Stats]) -> uint:
        return unsafe: uint<-read(value).attack ^ uint<-read(value).defense

    static function equal(a: const_ptr[Entity.Stats], b: const_ptr[Entity.Stats]) -> bool:
        let la = unsafe: read(a)
        let ra = unsafe: read(b)
        return la.attack == ra.attack and la.defense == ra.defense

## ── Generic function with interface constraint ──────────────────────
function damage_all[T implements Damageable](targets: span[T], amount: int) -> void:
    for i in 0..targets.len:
        if targets[i].is_alive():
            targets[i].take_damage(amount)

## Multiple constraints with 'and'
function describe[T implements Damageable and Named](target: ref[T]) -> str:
    let alive = if target.is_alive(): "alive" else: "dead"
    return f"#{target.display_name()} (#{alive})"

## ── Value parameter generic [N: int] ────────────────────────────────
function make_buffer[N: int]() -> str_buffer[N]:
    var buf: str_buffer[N]
    return buf

## ── inline if with a compile-time type comparison ───────────────────
function size_label[T]() -> str:
    inline if T == int:
        return "32-bit"
    inline if T == float:
        return "float"
    return "other"

## ── Error handling with Result[T, E] ────────────────────────────────
enum LoadError: ubyte
    not_found = 1
    invalid = 2

function load_entity(id: EntityId) -> Result[Entity, LoadError]:
    if id == 0:
        return Result[Entity, LoadError].failure(error = LoadError.not_found)
    return Result[Entity, LoadError].success(
        value = Entity.create(id, EntityKind.player, "Hero"),
    )

## Postfix ? propagation (enclosing must return compatible Result or Option)
function load_pair() -> Result[bool, LoadError]:
    let first = load_entity(1)?
    let second = load_entity(2)?
    io.print_line(f"Loaded #{first.name} and #{second.name}")
    return Result[bool, LoadError].success(value = true)

## ── Foreign FFI: raw external + foreign projection ──────────────────
external function atoi(input: cstr) -> int

## foreign function projects a raw ABI call into ordinary Milk Tea types
foreign function parse_int_foreign(input: str as cstr) -> int = atoi

## ── Events (fixed-capacity pub/sub, zero heap during dispatch) ──────
struct DamageEvent:
    target_id: EntityId
    amount: int

event entity_damaged[8](DamageEvent)

function on_damage(evt: DamageEvent) -> void:
    io.print_line(f"entity #{evt.target_id} took #{evt.amount} damage")

## ── Proc (closure with value captures) ──────────────────────────────
function make_scaler(factor: float) -> proc(x: float) -> float:
    return proc(x: float) -> float: x * factor

## ── Async / await ───────────────────────────────────────────────────
async function fetch_score(id: EntityId) -> int:
    return 42

async function load_scores() -> int:
    let a = await fetch_score(1)
    let b = await fetch_score(2)
    return a + b

## ── Compile-time constants for inline if ─────────────────────────────
const DEBUG: bool = false

## ── when: compile-time conditional (only the chosen branch is emitted) ──
enum Backend: ubyte
    gl     = 1
    vulkan = 2
const TARGET_BACKEND: Backend = Backend.gl

function backend_label() -> str:
    when TARGET_BACKEND:
        Backend.gl:
            return "OpenGL"
        Backend.vulkan:
            return "Vulkan"

## ── Main entry point ────────────────────────────────────────────────
function main() -> int:
    ## Local declarations: let (immutable), var (mutable)
    let width: int = 800
    var score: int = 0

    ## str_buffer: fixed-capacity mutable UTF-8 text
    var name_buf: str_buffer[64]
    name_buf.assign("World")
    name_buf.append("!")
    io.print_line(name_buf.as_str())

    ## Struct construction with named fields
    var player = Player(
        entity = Entity.create(1, EntityKind.player, "Hero"),
        score = 0,
        level = 1,
    )

    ## Tuple construction & destructuring
    let pair = (42, "hello")
    let (count, greeting) = pair
    let named_tuple = (x = 10, y = 20)
    let (tx, ty) = named_tuple

    ## Struct destructuring
    let Entity.Stats(attack, defense, speed) = player.entity.stats

    ## Guard binding: let...else: (initializer must be T?, Option[T], or Result[T, E])
    let entity = load_entity(1) else:
        return 1

    ## Guard with error binding
    let loaded = load_pair() else as error:
        io.print_line(f"load failed: #{error}")
        return 1

    ## Native vector types & arithmetic
    var position = vec3(x = 1.0, y = 2.0, z = 3.0)
    let direction = vec3(x = 0.0, y = 1.0, z = 0.0)
    position = position + direction * 0.5
    let dist = math.sqrt(double<-(position.x * position.x + position.y * position.y))

    ## Array, span, recoverable indexing
    var scores = array[int, 4](10, 20, 30, 40)
    scores[0] = 100
    let view: span[int] = scores.as_span()
    let maybe_val = get(scores, 99)
    if maybe_val == null:
        io.print_line("Index out of bounds (safe)")

    ## Range index assignment
    var buf: array[float, 4]
    buf[0..3] = (1.0, 2.0, 3.0)

    ## Collections: Vec and Map (import std.hash for primitive keys)
    var entities = vec.Vec[Entity].create()
    defer: entities.release()
    entities.push(Entity.create(1, EntityKind.player, "Hero"))
    entities.push(Entity.create(2, EntityKind.enemy, "Goblin"))

    var name_counts = map.Map[str, int].create()
    defer: name_counts.release()
    name_counts.set("player", 1)
    name_counts.set("enemy", 5)

    ## for loop: range
    for i in 0..3:
        io.print_line(f"index #{i}")

    ## for loop: array iteration with break / continue
    let values = array[int, 5](1, 2, 3, 4, 5)
    for v in values:
        if v == 3:
            continue
        if v == 5:
            break
        io.print_line(f"value #{v}")

    ## Lockstep for over arrays/spans (lengths must match)
    let xs = array[float, 3](1.0, 2.0, 3.0)
    let ys = array[float, 3](4.0, 5.0, 6.0)
    for x, y in xs, ys:
        io.print_line(f"#{x:.1} + #{y:.1}")

    ## while loop
    var n: int = 1
    while n < 100:
        if n > 50:
            break
        n = n * 2

    ## if / else if / else (conditions must be bool, no truthy coercion)
    if player.level > 10:
        io.print_line("veteran")
    else if player.level > 5:
        io.print_line("experienced")
    else:
        io.print_line("novice")

    ## if-expression
    let rank = if player.level >= 10: "master" else: "apprentice"

    ## match: enum (must be exhaustive or have _)
    match player.entity.kind:
        EntityKind.player:
            io.print_line("is player")
        EntityKind.enemy:
            io.print_line("is enemy")
        _:
            io.print_line("other")

    ## match: variant with struct patterns and guards
    let action = Action.attack(target_id = 2, damage = 15)
    match action:
        Action.move(dx, dy):
            io.print_line(f"move #{dx:.2}, #{dy:.2}")
        Action.attack(target_id, damage > 10):
            io.print_line(f"heavy attack on #{target_id}")
        Action.attack(target_id, damage):
            io.print_line(f"light attack on #{target_id}")
        Action.heal(amount):
            io.print_line(f"heal #{amount}")
        Action.idle:
            pass

    ## is: variant arm membership test
    if action is Action.attack:
        io.print_line("action is an attack")

    ## match expression
    let label = match player.level:
        1: "beginner"
        2: "novice"
        _: "advanced"

    ## Struct equality: field-wise ==/!=
    let stats_a = Entity.Stats(attack = 10, defense = 5, speed = 1.0)
    let stats_b = Entity.Stats(attack = 10, defense = 5, speed = 1.0)
    if stats_a == stats_b:
        io.print_line("stats equal")

    ## Explicit cast: T<-value
    let raw_kind = ubyte<-player.entity.kind
    let ratio = float<-score

    ## Format strings: interpolation, precision, hex, owned text
    io.print_line(f"Player: #{player.entity.name} HP=#{player.entity.hp}")
    io.print_line(f"Position: #{position.x:.2}, #{position.y:.2}")
    io.print_line(f"ID hex: #{player.entity.id:x}")
    var msg = fmt.format(f"Score: #{score}")
    defer: msg.release()

    ## Heredoc string
    let help = <<-HELP
        Commands:
          move, attack, quit
    HELP
    io.print_line(help)

    ## Defer: cleanup at scope exit (lowers to C cleanup labels)
    let data: own[int] = heap.must_alloc[int](1)
    defer: heap.release[int](data)

    ## Proc / closure
    let scale = make_scaler(2.5)
    let scaled = scale(10.0)

    ## Nullability: T? for any type (pointer-like shown here)
    var maybe_target: ptr[Entity]? = null
    if maybe_target == null:
        io.print_line("no target")

    ## unsafe: required for pointer indexing, dereference, arithmetic, casts
    unsafe:
        let p = ptr_of(score)
        read(p) = 42

    ## ref[T]: safe non-null writable alias (implicit borrow at call site)
    let handle = ref_of(player)
    handle.take_damage(10)
    io.print_line(f"HP after damage: #{player.entity.hp}")

    ## dyn[Interface] + adapt: runtime polymorphism (fat pointer)
    let d: dyn[Damageable] = adapt[Damageable](ref_of(player))
    d.take_damage(5)

    ## Events: subscribe, emit (emit only from declaring module)
    let sub = entity_damaged.subscribe(on_damage) else:
        return 1
    entity_damaged.emit(DamageEvent(target_id = 1, amount = 25))
    entity_damaged.unsubscribe(sub)

    ## .with() partial field update
    let updated = player.with_score(999)

    ## Compile-time reflection: inline for over struct fields
    inline for field in fields_of(Entity.Stats):
        io.print_line(f"field: #{field.name}")

    ## inline if: dead branch elimination (dead branch may reference nonexistent symbols)
    inline if DEBUG:
        io.print_line("debug mode")

    ## Foreign FFI, when, and inline-if type dispatch
    let parsed_int = parse_int_foreign("42")
    io.print_line(f"FFI parsed: #{parsed_int}")
    io.print_line(f"Backend: #{backend_label()}")
    io.print_line(f"int label: #{size_label[int]()}")

    ## ── Concurrency ─────────────────────────────────────────────────────
    ## parallel for: data-parallel loop dispatched across CPU cores
    var positions = array[float, 4](0.0, 1.0, 2.0, 3.0)
    var velocities = array[float, 4](0.1, 0.2, 0.3, 0.4)
    let dt: float = 0.016
    parallel for i in 0..4:
        positions[i] += velocities[i] * dt

    ## parallel: block for structured fork-join
    var pa: int = 0
    var pb: int = 0
    parallel:
        pa = 42
        pb = 99

    ## atomic[T]: lock-free concurrent access
    var counter: atomic[int]
    counter.store(0)
    let prev = counter.add(1)

    ## detach + gather: detached concurrency with explicit join
    let a = detach load_entity(100)
    let b = detach load_entity(200)
    gather a, b

    ## static_assert: compile-time assertions
    static_assert(size_of(int) == 4, "expected 32-bit int")
    static_assert(MAX_ENTITIES > 0, "need at least one entity")

    io.print_line(f"All done! Score=#{score}")
    return 0

import std.math as math
import std.raylib as rl

function main() -> int:
    return 0

external
include "raylib.h"
link "raylib"
compiler_flag "-DPLATFORM_DESKTOP"

struct Color:
    r: ubyte
    g: ubyte
    b: ubyte
    a: ubyte

external function InitWindow(width: int, height: int, title: cstr) -> void

import std.str
import std.vec
import mylib.utils

## Preferred: wrap in delimiters.
let total = (
    subtotal
    + tax
    - discount
)

## Also accepted: operator-led continuation.
let total = subtotal +
    tax -
    discount

## The continuation operator set is closed:
## + - * / % | & ^ << >> == != < <= > >= and or is ..
## Member-access chains exceeding one line wrap in () with leading dots:
let total = (
    values.iter()
        .filter(pred)
        .fold(0, add)
)

let width: int = 1280       ## immutable
var score: int = 0           ## mutable
let dt = rl.get_frame_time() ## type inferred (float)
var player_count = 0         ## type inferred (int)

## Zero-initialized (explicit type required, must be zero-initializable):
var scratch: array[ubyte, 256]

const GRAVITY: float = 9.81

## Block-bodied const (evaluated at compile time)
const NEXT_POW2 -> int:
    var n: int = 1
    while n < 1024:
        n = n * 2
    return n

## Tuple destructuring
let (a, b) = pair()
let (x, y) = (1, 2)

## Struct destructuring
struct Vec2:
    x: float
    y: float
let p = Vec2(x = 1.0, y = 2.0)
let Vec2(x, y) = p

let window = maybe_window else:
    return 1

let image = load_image(path) else:
    return 1

let config = load_config() else as error:
    return error

let _ = initialize_runtime() else:
    return 1

let parsed = parse(input)?
let lowered = lower(parsed)?
return Result[Output, Error].success(value = lowered)

type Seconds = float
type Callback = fn(level: int, message: cstr) -> void

struct Vec2:
    x: float
    y: float

## With attributes
@[packed]
struct Header:
    tag: ubyte

@[align(16)]
struct Mat4:
    data: array[float, 16]

## Nested structs (qualified as Parent.Nested)
struct Rectangle:
    x: float
    y: float

    struct Edge:
        start: float
        end: float

    top_edge: Edge
    left_edge: Edge

union Number:
    i: int
    f: float

## Explicit type and values (classic form)
enum State: ubyte
    idle = 0
    running = 1

## Backing type and values both optional
enum Color:
    red        ## 0
    green      ## 1
    blue       ## 2

## Auto-increment from explicit value
enum Status:
    idle = 10   ## 10
    running     ## 11
    stopped     ## 12

flags Mask: uint
    a = 1 << 0
    b = 1 << 1
    both = Mask.a | Mask.b     ## composite alias

variant Token:
    ident(text: str)
    number(value: int)
    eof

## Constructors
let t1 = Token.ident(text = "hello")  ## payload arm
let t2 = Token.eof                     ## no-payload arm

## Generic variants
variant Option[T]:
    some(value: T)
    none

variant Result[T, E]:
    success(value: T)
    failure(error: E)

struct Vec2:
    x: float
    y: float

variant Shape:
    circle(radius: float)
    square(side: float)

function same_point(a: Vec2, b: Vec2) -> bool:
    return a == b

function same_shape(a: Shape, b: Shape) -> bool:
    return a == b

opaque SDL_Window implements Closable
opaque ma_engine

attribute[field] rename(name: str)
attribute[struct, event] trace(name: str)

@[trace(name = "player")]
struct Player:
    @[rename(name = "hp")]
    health: int

static_assert(size_of(int) == 4, "expected 32-bit int")
static_assert(MAX_ENTITIES > 0, "need at least one entity")

public interface Damageable:
    editable function take_damage(amount: int) -> void
    function is_alive() -> bool

## Generic interface
interface Mapper[T]:
    function map(x: T) -> T

## Conformance on nominal type
struct NPC implements Damageable:
    hp: int
    name: str

extending Counter:
    function read() -> int:
        return this.value

    editable function bump() -> void:
        this.value += 1

    static function zero() -> Counter:
        return Counter(value = 0)

function render_all(drawables: span[dyn[Drawable]]):
    for d in drawables:
        d.draw()

let d: dyn[Drawable] = adapt[Drawable](ref_of(entity))

let v = vec3(x = 1.0, y = 2.0, z = 3.0)
let m = mat4(
    col0 = vec4(x = 1.0, y = 0.0, z = 0.0, w = 0.0),
    col1 = vec4(x = 0.0, y = 1.0, z = 0.0, w = 0.0),
    col2 = vec4(x = 0.0, y = 0.0, z = 1.0, w = 0.0),
    col3 = vec4(x = 0.0, y = 0.0, z = 0.0, w = 1.0),
)
let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)

let window: ptr[Window]? = null
let name: cstr? = null
let port: int? = null        ## value-type optional, stored inline

## Typed null for ambiguous contexts (target must be pointer-like)
let handle = null[ptr[char]]

## Generic struct
struct Slice[T]:
    data: ptr[T]
    len: ptr_uint

## Generic function with constraint
function damage_one[T implements Damageable](target: ref[T], amount: int) -> void:
    if target.is_alive():
        target.take_damage(amount)

## Multiple constraints
function update_and_draw[T implements Updatable and Drawable](value: ref[T]):
    value.update()
    value.draw()

## Value parameter
function int_with_bits[N: int]() -> type:
    if N == 64:
        return long
    else:
        return int

## Specialization
let big = int_with_bits[64]()
let s64 = Slice[ubyte](data = ptr, len = 32)

function add(a: int, b: int) -> int:
    return a + b

## Return type defaults to void
function say_hello(name: str):
    io.print_line(f"Hello, #{name}!")

const function square(x: int) -> int:
    return x * x

const RESULT: int = square(5)   ## folded to 25 at compile time

external function printf(format: cstr, ...) -> int

foreign function init_window(width: int, height: int, title: str as cstr) -> void = c.InitWindow
foreign function load_file_data(file_name: str as cstr, out data_size: int) -> ptr[ubyte]? = c.LoadFileData
foreign function close_window(consuming window: Window) -> void = c.CloseWindow

let multiplier = 2
let doubler = proc(x: int) -> int:
    return x * multiplier

## Expression-bodied
let tripler = proc(x: int) -> int: x * 3

if ready:
    start_game()
else if wants_menu:
    open_menu()
else:
    show_intro()

## Inline form: single statement on same line
if ready: return 1 else: return 0
if x > 10: return "big" else if x > 5: return "med" else: return "small"

while running:
    tick()

for i in 0..count:
    update_enemy(i)

for item in items:
    process(item)

for entity, position, velocity in entities, positions, velocities:
    update(entity, position, velocity)

if debug_mode:
    pass
else:
    do_work()

let text: str = "hello world"
let head = text[0..5]              # str view: "hello"
var values: array[int, 4] = (10, 20, 30, 40)
let middle = values[1..3]          # span[int] view over 20, 30

var buf: array[float, 4]
buf[0..3] = (1.0, 2.0, 3.0)   # assigns buf[0], buf[1], buf[2]

## Enum match (must be exhaustive unless _ present)
match kind:
    EventKind.quit:
        return 0
    _:
        return 1

## Integer match (_ required)
match key_code:
    65:
        fire()
    27:
        quit()
    _:
        return

## Variant match with payload binding
match token:
    Token.ident(text):
        use_name(text)
    Token.number as n:
        use_value(n.value)
    Token.eof:
        return

let label = match code:
    1: "one"
    2: "two"
    _: "other"

## str match (_ required)
let cmd_label = match command:
    "lex": "lexer"
    "parse": "parser"
    _: "unknown"

## No-payload arm
if kind is TokenKind.eof:
    break

## Payload arm (any payload matches)
if kind is TokenKind.identifier:
    process_ident()

## With logical operators
if kind is TokenKind.eof or kind is TokenKind.indent:
    break

## In a let binding
let ok = kind is TokenKind.op_plus

let a = TokenKind.eof
let b = TokenKind.eof
if a == b:
    io.print_line("same arm")

let id1 = TokenKind.ident(name = "hello")
let id2 = TokenKind.ident(name = "hello")
if id1 == id2:
    io.print_line("same payload")

if id1 != TokenKind.eof:
    io.print_line("different arm")

match entity:
    Entity.player(hp > 0, position):
        render(position)
    Entity.player:
        remove()
    Entity.enemy:
        return

## _ discards a field without binding it
match record:
    Record.fields(_, _, _, label):
        use_label(label)

function main() -> int:
    rl.init_window(800, 600, "Game")
    defer: rl.close_window()

    while not rl.window_should_close():
        rl.begin_drawing()
        defer: rl.end_drawing()
        render_frame()

    return 0

## Expression form
let p = unsafe: pixels + offset

## Block form
unsafe:
    let pixel = read(ptr[uint]<-p)
    pointer[0] = 1
    pointer[1] = 2

## str concatenation folds to a literal
const GREET: str = "hello" + " " + "world"

## match expressions fold
const LABEL -> str:
    return match 2:
        1: "one"
        2: "two"
        _: "other"

## const methods fold too
struct Rect:
    w: int
    h: int
    const function area() -> int:
        return this.w * this.h

const R: Rect = Rect(w = 10, h = 20)
const AREA: int = R.area()   ## folded to 200 at compile time

when TARGET_OS:
    TargetOs.linux:
        return open_linux(path)
    TargetOs.windows:
        return open_windows(path)

inline for field in fields_of(Particle):
    static_assert(field.type == float, "Particle fields must be float")

const DEBUG_RENDER: bool = false

function draw() -> void:
    inline if DEBUG_RENDER:
        debug_overlay()
    else:
        normal_draw()

inline match TARGET_BACKEND:
    Backend.gl:
        gl_draw(item)
    Backend.vulkan:
        vk_draw(item)

inline while n < 1024:
    n = n * 2

const function generate_helpers() -> void:
    emit function meaning_of_life() -> int:
        return 42
    emit function greet() -> str:
        return "hello"

## Identifiers, literals, parenthesized expressions
let x = (a + b) * c

## Tuple literals
let pair = (42, "hello")          ## positional
let point = (x = 10, y = 20)      ## named

## Type queries (compile-time)
let s = size_of(int)
let a = align_of(Mat4)
let o = offset_of(Vec2, y)

## If-expressions
let max = if a > b: a else: b

## Match-expressions
let label = match code:
    1: "one"
    2: "two"
    _: "other"

## Proc expressions
let add_one = proc(x: int) -> int: x + 1

## Member access, indexing, calls
value.field
arr[i]
func(arg)

## Range index: str returns str view; arrays and spans return span[T] view
let head = text[0..5]
let middle = values[1..3]

## Partial field update (returns copy)
let moved = v.with(x = 10.0)

## Specialization (bare or module-qualified names only)
let spec = name[T]
let sized = name[32]

inline for field in fields_of(Point):
    let sz = size_of(field.type)
    let off = offset_of(Point, field)
    static_assert(sz > 0, "field has non-zero size")

## Per-field equality via field.type used in type position (content-correct)
function field_equal[T](a: const_ptr[T], b: const_ptr[T]) -> bool:
    inline for field in fields_of(T):
        let off = offset_of(T, field)
        unsafe:
            let pa = const_ptr[field.type]<-(ptr[ubyte]<-a + off)
            let pb = const_ptr[field.type]<-(ptr[ubyte]<-b + off)
            if not equal[field.type](pa, pb):
                return false
    return true

let text = f"count=#{count} ok=#{ready}"

## Precision for floats
let info = f"value=#{pi:.4}"

## Hex format for ints
let hex = f"address=#{ptr_value:x}"

## Owned text with explicit release
import std.fmt
let owned = fmt.format(f"count=#{count}")  ## -> string.String (call .release())

extending MyType:
    function format_len() -> ptr_uint:
        return ...  # byte length of formatted output
    function append_format(output: ref[string.String]) -> void:
        ...         # write formatted bytes into output

## str heredoc
const help: str = <<-HELP
    Usage: tool [options]
    Options:
      --help    Show this message
HELP

## cstr heredoc
const shader: cstr = c<<-GLSL
    #version 330
    void main() {
        gl_FragColor = vec4(1.0);
    }
GLSL

## Format heredoc
let msg = f<<-MSG
    Hello, #{name}!
    Score: #{score}
MSG

let text = "hello "
    "from multiple "
    "indented lines"   # produces "hello from multiple indented lines"

async function child() -> int:
    return 41

async function parent() -> int:
    let v = await child()
    return v + 1

## async main is compiler-bootstrapped
async function main() -> int:
    let result = await do_work()
    return result

import std.async as aio

let task = some_async_work()
aio.wait(task)
let r = aio.result(task)

parallel for i in 0..entity_count:
    positions[i] += velocities[i] * dt

parallel:
    load_textures(path)
    load_sounds(path)

var counter: atomic[int]
counter.store(0)
let prev = counter.add(1)     # returns previous value
let value = counter.load()
counter.sub(1)
let old = counter.exchange(42)

let a = detach load_textures(path)
let b = detach load_sounds(path)
process_other_stuff()
gather a, b

public event closed[4]
public event resized[8](ResizeEvent)

## As struct members
struct Window:
    public event closed[4]
    public event resized[8](ResizeEvent)

## Subscribe
let sub = window.closed.subscribe(on_close)?

## One-shot
let once = window.resized.subscribe_once(on_resize)?

## Unsubscribe
window.closed.unsubscribe(sub)

## Emit (only from declaring module)
closed.emit()
resized.emit(ResizeEvent(width = 800, height = 600))

## Async wait for next emission
let payload = await event.wait()

struct ResizeEvent:
    width: int
    height: int

struct Window:
    public event closed[4]
    public event resized[8](ResizeEvent)

function on_close() -> void:
    io.print_line("closed")

function attach(window: ref[Window]) -> Result[void, EventError]:
    let closed_sub = window.closed.subscribe(on_close)?
    let resized_sub = window.resized.subscribe(on_resize)?

    defer: window.closed.unsubscribe(closed_sub)
    defer: window.resized.unsubscribe(resized_sub)

    return Result[void, EventError].success()

mtc lint path/to/file.mt           # report all diagnostics
mtc lint path/to/file.mt --fix     # auto-apply safe fixes
mtc lint path/to/file.mt --select unused-import  # only selected rules
mtc lint path/to/file.mt --ignore line-too-long  # skip selected rules

var count = 0  # lint: ignore
var total = 0  # lint: ignore(prefer-let, dead-assignment)

max_line_length: 120
select:
    - line-too-long
    - prefer-let
    - missing-return
ignore:
  - shadow
  - useless-expression