ludic/examples/annotations.ludic
Orkuncakilkaya e9c15cc620 Phase 7e: polymorphic print(x) + str(x) (retire print_int/print_str)
One `print` instead of two C-style names: `print(x)` writes an int OR a string
followed by a newline, dispatching on the operand type (int -> %d, string ->
%s). `print(int)` emits byte-identically to the old print_int, so every existing
call and every smoke-test output is unchanged.

print_str was only ever the raw IR-to-stdout dump in ir_flush (no newline), which
is not "printing a line" — so it now uses file_write to a new file_stdout()
stream, keeping the emitted IR byte-for-byte identical. That frees `print` to
have consistent always-newline semantics.

Two reseeds: (A) add print + str + file_stdout keeping the intrinsics; (B)
migrate the 61 print_int calls to print, ir_flush to file_write(file_stdout()),
and delete print_int/print_str (+ the now-dead @.fmt_str). str(x) (the
interpolation converter from 7d) is now also a documented standalone builtin.

Vocabulary: print/str/file_stdout in, print_int/print_str out (ludic_syntax.h,
grammar, LudicTokens.kt). LANGUAGE.md updated. Reseeded (22551 lines); C-free
fixpoint holds; goldens identical; 18/18; vocab + doc-fences clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-08-28 01:22:38 +03:00

37 lines
1.3 KiB
Text

# annotations.ludic — the annotation-first style. Behaviour is expressed with
# @-decorators that desugar to plain handlers, queries and expressions, so the
# properties stay pure data and the data-oriented model is untouched.
@Handles(Move)
program RPG2D {
property Transform { x: int = 0, y: int = 0, scale: int = 1 }
property Velocity {
dx: int = 0
dy: int = 0
@Computed speed2: int = dx * dx + dy * dy # derived; no storage, inlined at use
}
model Actor { Transform, Velocity }
# A constructor: every Actor starts visible. Runs at spawn with the model's
# properties bound by name — no per-frame cost, no observer machinery.
@OnSpawn(Actor)
handler InitActor { Transform.scale = 2 }
handler Spawn phase Start {
spawn Actor { Transform { x: 0 } Velocity { dx: 3, dy: 4 } }
spawn Actor { Transform { x: 0 } Velocity { dx: 0, dy: 0 } }
}
# Move every Actor whose scale is positive and that is actually moving. The
# query is the decorator; each bound property is addressed by its own name.
@Queries(these: [Transform{scale > 0}, Velocity{dx > 0 or dy > 0}], on: Actor)
handler Move phase Update {
Transform.x = Transform.x + Velocity.dx
Transform.y = Transform.y + Velocity.dy
}
handler Report phase Render {
for (t, v) in query [Transform, Velocity] { print(t.x); print(v.speed2) }
quit()
}
}