novac 2.0.1 → 2.2.0

package/novac/demo.nv

@@ -0,0 +1,245 @@
+/! Nova Language v2 — Feature Showcase
+let tcc
+on "nv:tick" (ps) {tcc++}
+// ── F-Strings ──
+let name = "Nova";
+core.print(f"Welcome to {name} v2!");
+core.print(f"2^10 = {2**10}");
+
+// ── Structs ──
+struct Vec2 {
+  x: int = 0,
+  y: int = 0
+}
+let pos = Vec2({ x: 3, y: 4 });
+core.print(f"pos = ({pos.x}, {pos.y})");
+core.print(f"typeOf pos = {typeOf(pos)}");
+
+// ── Enums ──
+enum Status { Active, Inactive, Pending }
+let st = Status.Active;
+core.print(f"status = {st.__variant__}");
+
+// ── Interfaces ──
+interface Serializable { serialize() }
+let doc = { serialize() { give "doc-json"; } };
+let isSer = satisfies(doc, "Serializable");
+core.print(f"satisfies Serializable: {isSer}");
+
+// ── Pattern matching with range patterns ──
+let score = 85;
+match (score) {
+  when 90..100 { core.print("A grade"); }
+  when 80..89  { core.print("B grade"); }
+  when 70..79  { core.print("C grade"); }
+  default      { core.print("Below C"); }
+}
+
+// ── Pipe operator ──
+func double(x) => { give x * 2; }
+func addOne(x) => { give x + 1; }
+let piped = 5 |> double |> addOne;
+core.print(f"5 |> double |> addOne = {piped}");
+
+// ── Each loop with index ──
+let total = 0;
+each n, i of [10, 20, 30, 40] {
+  total += n;
+}
+core.print(f"each total = {total}");
+
+// ── Events ──
+let tickCount = 0;
+on "a" (count) {
+  tickCount += 1;
+}
+emit "a", 1;
+emit "a", 2;
+core.print(f"ticks received = {tickCount}");
+
+// ── Where scoping ──
+where (base = 100, taxRate = 0.15) {
+  let tax = base * taxRate;
+  print(f"tax = {tax}");
+}
+
+// ── Array methods ──
+let nums = [5, 3, 8, 1, 9, 2];
+let evens   = nums.filter(x => x % 2 == 0);
+let doubled = nums.map(x => x * 2);
+let sum     = nums.reduce((acc, x) => acc + x, 0);
+core.print(f"evens   = {evens.join(", ")}");
+core.print(f"doubled = {doubled.join(", ")}");
+core.print(f"sum     = {sum}");
+core.print(f"sorted  = {nums.sort().join(", ")}");
+
+// ── Optional chaining ──
+let user = { profile: { email: "a@b.com" } };
+let email = user?.profile?.email;
+let phone = user?.profile?.phone ?? "N/A";
+core.print(f"email = {email}");
+core.print(f"phone = {phone}");
+
+// ── Spread / rest params ──
+func stats(...ns) => {
+  let lo = ns.reduce((a, x) => a < x ? a : x);
+  let hi = ns.reduce((a, x) => a > x ? a : x);
+  give { min: lo, max: hi };
+}
+let st2 = stats(3, 7, 1, 9, 4);
+core.print(f"min={st2.min}  max={st2.max}");
+
+// ── Nullish / logical assignment ──
+let maybe = null;
+maybe ??= "default";
+core.print(f"nullish assign = {maybe}");
+
+// ── Classes with inheritance ──
+class Shape {
+  color: "black"
+  describe() { core.print(f"Shape ({this.color})"); }
+}
+class Circle extends Shape {
+  radius: 5
+  area() { give 3.14159 * this.radius * this.radius; }
+  describe() {
+    print(f"Circle r={this.radius} color={this.color}");
+  }
+}
+let c = Circle();
+c.color = "red";
+c.describe();
+core.print(f"circle area = {c.area()}");
+
+// ── Switch / case ──
+let day = 3;
+switch (day) {
+  case 1: core.print("Mon"); break;
+  case 2: core.print("Tue"); break;
+  case 3: core.print("Wed"); break;
+  default: core.print("Other"); break;
+}
+
+// ── Bitwise + range operators ──
+core.print(f"6 & 3 = {6 & 3}");
+core.print(f"6 | 3 = {6 | 3}");
+core.print(f"2**10 = {2**10}");
+core.print(f"5 in 1..10 = {5 in 1..10}");
+
+// ── Assert ──
+assert 2 + 2 == 4, "math broken";
+assert typeof "x" == "string", "typeof broken";
+core.print("all assertions passed");
+
+// ── Preprocessor ──
+#define LANG Nova
+#define VER  2
+core.print(f"Language: {LANG} v{VER}");
+
+/! ── Nova Classic features demo ──
+
+// foreach loop
+let scores = { alice: 95, bob: 82, carol: 71 };
+foreach(scores)(name, val) {
+  core.print(f"  {name}: {val}");
+}
+
+// temp binding
+let config = "production";
+temp config = "test" => {
+  core.print(f"in temp scope: {config}");
+}
+core.print(f"after temp: {config}");
+
+// keep (set-once)
+keep serverPort = 8080;
+keep serverPort = 9999;
+core.print(f"port stays: {serverPort}");
+
+// macro
+macro VERSION = 2;
+core.print(f"Nova v{VERSION}");
+
+// addto
+let evtLog = [];
+addto evtLog "startup";
+addto evtLog "ready";
+core.print(f"log has {evtLog.length} entries");
+
+// lambda
+lambda square = x => x * x;
+core.print(f"square(7) = {square(7)}");
+
+// compose (fn pipeline with >>)
+func trim(s)  => { give s; }
+func shout(s) => { give f"{s}!"; }
+compose announce = trim >> shout;
+core.print(announce("hello"));
+
+// partial application
+func multiply(a, b) => { give a * b; }
+partial triple = multiply(3);
+core.print(f"triple(7) = {triple(7)}");
+
+// backup / retrieve
+let userSession = "user_abc";
+backup userSession = userSession;
+let userSession = "guest";
+retrieve userSession;
+core.print(f"restored: {userSession}");
+
+// Nova Classic infix operators
+core.print(f"7 xor 7 = {7 xor 7}");
+core.print(f"true nand true = {true nand true}");
+let _numtype = "number"; core.print(f"42 istypeof number = {42 istypeof _numtype}");
+let _hw = "hello"; let _pat = "hel"; core.print(f"hello matches hel = {_hw matches _pat}");
+
+// set operations
+let a = [1, 2, 3, 4];
+let b = [3, 4, 5, 6];
+core.print(f"intersect: {a intersect b}");
+core.print(f"union:     {a union b}");
+core.print(f"diff:      {a diff_arr b}");
+
+// zip
+let pairs = [1, 2, 3] zip ["a", "b", "c"];
+core.print(f"zip[0]: {pairs[0][0]}-{pairs[0][1]}");
+
+// numeric operators
+core.print(f"8 avg 12  = {8 avg 12}");
+core.print(f"gcd 12 8  = {12 gcd 8}");
+core.print(f"lcm 4 6   = {4 lcm 6}");
+
+// rate casts (typed casting)
+core.print(f"rate(3.7) int  = {rate(3.7) int}");
+core.print(f"rate(300) u8   = {rate(300) u8}");
+let _s = "hi"; core.print(f"rate(hi) char  = {rate(_s) char}");
+
+// classify
+core.print(f"classify 42 as int   = {classify 42 as int}");
+core.print(f"classify type of 42  = {classify 42}");
+
+// QAEs — query assertions / predicates
+core.print(f"qae.prime(17) = {qae.prime(17)}");
+let _rc="racecar"; core.print(f"qae.palindrome(racecar) = {qae.palindrome(_rc)}");
+core.print(f"qae.even(8) = {qae.even(8)}");
+core.print(f"qae.ascending([1,2,3]) = {qae.ascending([1,2,3])}");
+
+// novaRegex — semantic regex
+let emailRegex = novaRegex("<email>"); let _em = "a@b.com";
+core.print(f"email match: {emailRegex.test(_em)}");
+
+// step operator (range with step)
+let evens = 0..10 step 2;
+core.print(f"evens[0..3]: {evens[0]} {evens[1]} {evens[2]}");
+
+// extend (object merge)
+let base = { name: "Nova", version: 2 };
+let ext  = { stable: true };
+let merged = base extend ext;
+core.print(f"merged.stable = {merged.stable}");
+
+// describe annotation
+describe "Nova v2 feature showcase complete";
+core.print("-- demo end --");
+print('Total ticks: ' + tcc)

package/novac/demo_builtins.nv

@@ -0,0 +1,209 @@
+/! Nova Built-in Objects + Unified Registry Demo
+
+core.print("=== Unified nova Registry ===");
+
+macro APP_NAME = NovaDemoApp;
+macro BUILD = 2;
+core.print(f"App: {nova.getMacro('APP_NAME')} build {nova.getMacro('BUILD')}");
+core.print(f"Nova version: {nova.version}");
+
+describe "Built-ins showcase";
+core.print(f"descriptions: {nova.descriptions[0]}");
+
+struct Config { host: string = "localhost", port: int = 8080 }
+core.print(f"registered structs: {nova.types.structs[0]}");
+
+let evResult = nova.eval("10 * 5 + 2");
+core.print(f"nova.eval result: {evResult}");
+
+core.print("\n=== ForLoop ===");
+let squares = ForLoop({ from: 1, to: 5 }).map(i => i * i).collect();
+core.print(f"squares: {squares.join(', ')}");
+
+let evens = ForLoop({ from: 0, to: 20, step: 2 }).toArray();
+core.print(f"evens[0..4]: {evens[0]} {evens[1]} {evens[2]} {evens[3]} {evens[4]}");
+
+let sumResult = 0;
+ForLoop({ from: 1, to: 100 }).do(i => { sumResult += i; }).run();
+core.print(f"sum 1..100 = {sumResult}");
+
+core.print("\n=== Pipeline ===");
+let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let processed = Pipeline(data)
+  .filter(x => x % 2 == 0)
+  .map(x => x * x)
+  .take(4)
+  .collect();
+core.print(f"pipeline result: {processed.join(', ')}");
+
+let total = Pipeline([1, 2, 3, 4, 5]).reduce((acc, x) => acc + x, 0);
+core.print(f"pipeline reduce: {total}");
+
+core.print("\n=== IfBlock ===");
+let score = 87;
+let grade = IfBlock({ cond: score >= 90, then: () => "A" })
+  .elseIf(score >= 80, () => "B")
+  .elseIf(score >= 70, () => "C")
+  .else(() => "F")
+  .run();
+core.print(f"grade for {score}: {grade}");
+
+core.print("\n=== MatchBlock ===");
+let status = MatchBlock(404)
+  .when(200, () => "OK")
+  .when(404, () => "Not Found")
+  .when(500, () => "Server Error")
+  .default(() => "Unknown")
+  .run();
+core.print(f"HTTP 404 = {status}");
+
+let rangeMatch = MatchBlock(75)
+  .when(90..100, x => "A")
+  .when(80..89,  x => "B")
+  .when(70..79,  x => "C")
+  .default(x => "F")
+  .run();
+core.print(f"range match 75: {rangeMatch}");
+
+core.print("\n=== TryCatch ===");
+let caught = "";
+TryCatch()
+  .try(() => { throw "oops"; })
+  .catch(e => { caught = e; })
+  .finally(() => core.print("finally ran"))
+  .run();
+core.print(f"caught: {caught}");
+
+core.print("\n=== Data Structures ===");
+let stk = Stack();
+stk.push(10); stk.push(20); stk.push(30);
+core.print(f"Stack: push 10,20,30 → pop={stk.pop()} peek={stk.peek()}");
+
+let que = Queue();
+que.enqueue("first"); que.enqueue("second"); que.enqueue("third");
+core.print(f"Queue: dequeue={que.dequeue()} size={que.size}");
+
+let ll = LinkedList();
+ll.push("a").push("b").push("c");
+core.print(f"LinkedList size={ll.size} shift={ll.shift()} remaining={ll.size}");
+
+let cnt = Counter(0);
+cnt.increment(5); cnt.decrement(2); cnt.clamp(0, 10);
+core.print(f"Counter: {cnt.value}");
+
+core.print("\n=== State Machine ===");
+let sm = State("idle");
+sm.add("idle",    "start", "running")
+  .add("running", "pause", "paused")
+  .add("paused",  "resume","running")
+  .add("running", "done",  "idle");
+sm.onEnter("running", s => core.print(f"  → entered {s}"));
+sm.onExit("idle",     s => core.print(f"  ← leaving {s}"));
+sm.dispatch("start");
+sm.dispatch("pause");
+sm.dispatch("resume");
+sm.dispatch("done");
+core.print(f"Final state: {sm.current}");
+core.print(f"History: {sm.history.join(' → ')}");
+
+core.print("\n=== Observable + Signal ===");
+let obs = Observable(0);
+let obsLog = [];
+obs.subscribe(v => { addto obsLog v; });
+obs.value = 10;
+obs.value = 20;
+obs.value = 30;
+core.print(f"Observable changes: {obsLog.join(', ')}");
+
+let sig = Signal(1);
+let doubled = sig.derive(x => x * 2);
+let quad    = doubled.derive(x => x * 2);
+core.print(f"Signal chain: {sig.value} → {doubled.value} → {quad.value}");
+sig.value = 5;
+core.print(f"After sig=5:  {sig.value} → {doubled.value} → {quad.value}");
+
+core.print("\n=== Validator ===");
+let numV = Validator().required().type("number").min(0).max(100);
+let r1 = numV.validate(50);
+let r2 = numV.validate(-5);
+let r3 = numV.validate(null);
+core.print(f"validate(50):   valid={r1.valid}");
+core.print(f"validate(-5):   valid={r2.valid} errors={r2.errors[0]}");
+core.print(f"validate(null): valid={r3.valid} errors={r3.errors[0]}");
+
+let emailV = Validator().email();
+core.print(f"email ok:  {emailV.validate('a@b.com').valid}");
+core.print(f"email bad: {emailV.validate('notanemail').valid}");
+
+core.print("\n=== DataStream ===");
+let stream = DataStream([5, 3, 8, 1, 9, 2, 7, 4, 6]);
+let top3 = stream.filter(x => x > 3).sort().reverse().take(3).collect();
+core.print(f"top 3 > 3: {top3.join(', ')}");
+
+let distinct = DataStream([1, 2, 2, 3, 3, 3, 4]).distinct().collect();
+core.print(f"distinct: {distinct.join(', ')}");
+
+core.print("\n=== Memo ===");
+let calls = 0;
+let expensiveFn = x => { calls++; give x * x * x; };
+let memoFib = Memo(expensiveFn);
+memoFib.call(5); memoFib.call(5); memoFib.call(5);
+memoFib.call(3); memoFib.call(3);
+core.print(f"Memo: 5 calls deduped to {calls} actual runs");
+core.print(f"Stats: {memoFib.stats.hits} hits, {memoFib.stats.misses} misses");
+
+core.print("\n=== Lazy ===");
+let computed = false;
+let lazy = Lazy(() => { computed = true; give "expensive result"; });
+core.print(f"Before access: computed={computed}");
+core.print(f"Value: {lazy.value}");
+core.print(f"After access: computed={computed}");
+core.print(f"Value again (cached): {lazy.value}");
+
+core.print("\n=== Router ===");
+let router = Router();
+router.on("/api/users/(.*)",   id   => f"GET user {id}")
+      .on("/api/posts/(.*)",   id   => f"GET post {id}")
+      .on("/api/(.*)/delete",  res  => f"DELETE {res}")
+      .default(path => f"404: {path}");
+
+core.print(router.dispatch("/api/users/42"));
+core.print(router.dispatch("/api/posts/7"));
+core.print(router.dispatch("/api/comments/delete"));
+core.print(router.dispatch("/unknown"));
+
+core.print("\n=== EventBus (standalone) ===");
+let bus = EventBus();
+let busLog = [];
+bus.on("data",  v => { addto busLog f"data:{v}"; });
+bus.on("error", e => { addto busLog f"err:{e}";  });
+bus.once("ready", () => { addto busLog "ready!"; });
+bus.emit("ready");
+bus.emit("data", 42);
+bus.emit("data", 99);
+bus.emit("error", "timeout");
+bus.emit("ready");  // once — no second fire
+core.print(f"Bus log: {busLog.join(', ')}");
+
+core.print("\n=== Transformer ===");
+let jsonT = TransformerJSON();
+let encoded = jsonT.to({ name: "Nova", version: 2 });
+core.print(f"JSON encode: {encoded}");
+
+let b64T = TransformerBase64();
+let b64enc = b64T.to("Hello Nova!");
+let b64dec = b64T.from(b64enc);
+core.print(f"Base64 round-trip: {b64dec}");
+
+core.print("\n=== WhileLoop class ===");
+let wn = 1;
+WhileLoop({}).cond(() => wn < 32).do(() => { wn *= 2; }).run();
+core.print(f"WhileLoop powers of 2: {wn}");
+
+core.print("\n=== FuncDef ===");
+let adder = FuncDef({ args: ["a", "b"], body: (a, b) => a + b }).named("add");
+core.print(f"FuncDef call: {adder.call(10, 32)}");
+let arrowFn = adder.toArrow();
+core.print(f"FuncDef arrow: {arrowFn(7, 8)}");
+
+core.print("\n-- builtins demo done --");

package/novac/demo_http.nv

@@ -0,0 +1,62 @@
+/! Nova v2 — HTTP / Server feature demo
+
+// ── 1. First-class URL token ──
+let endpoint = https://jsonplaceholder.typicode.com/todos/1;
+core.print(f"URL value: {endpoint}");
+
+// ── 2. First-class HTTP method expression ──
+core.print("Fetching todo via GET expression...");
+let todo = get https://jsonplaceholder.typicode.com/todos/1();
+core.print(f"  title  : {todo.body.title}");
+core.print(f"  status : {todo.status}");
+core.print(f"  ok     : {todo.ok}");
+
+// ── 3. Sync fetch() function ──
+core.print("Fetching post via fetch()...");
+let article = fetch("https://jsonplaceholder.typicode.com/posts/1");
+core.print(f"  article title: {article.body.title}");
+
+// ── 4. fetch() statement form with => binding ──
+fetch("https://jsonplaceholder.typicode.com/todos/2") => todo2;
+core.print(f"  todo2: {todo2.body.title}");
+
+// ── 5. POST with body ──
+core.print("POST request...");
+let created = post https://jsonplaceholder.typicode.com/posts({ title: "Nova test", body: "hello", userId: 1 });
+core.print(f"  created id: {created.body.id}");
+core.print(f"  created status: {created.status}");
+
+// ── 6. Server ──
+core.print("Starting server on port 4242...");
+server(4242) {
+  get "/hello"(req, res) {
+    return { message: "Hello from Nova!", method: req.method };
+  }
+
+  get "/echo/:msg"(req, res) {
+    return { echo: req.params.msg };
+  }
+
+  post "/data"(req, res) {
+    let incoming = req.body;
+    return { received: true, data: incoming };
+  }
+
+  get "*"(req, res) {
+    res.status(404);
+    return { error: "Not found", path: req.path };
+  }
+}
+
+// Hit the local server
+core.print("Testing server with local requests...");
+let r1 = get http://localhost:4242/hello();
+core.print(f"  /hello -> {r1.body.message}");
+
+let r2 = get http://localhost:4242/echo/world();
+core.print(f"  /echo/world -> {r2.body.echo}");
+
+let r3 = post http://localhost:4242/data({ name: "Nova", version: 2 });
+core.print(f"  /data received: {r3.body.received}");
+
+core.print("All HTTP tests passed!");

package/novac/examples/bf.nv

@@ -0,0 +1,69 @@
+let Tkit = includeKit("libterm");
+let TView = Tkit.TView;
+let Terminal = Tkit.Terminal;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Boot Terminal (starts input, enters alt-screen, wires resize)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const term = Terminal({
+  altScreen: true,
+  mouse:     true,
+  theme:     'dark',
+  logLevel:  'debug',
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Layout: top bar / [left pane | right pane] / sensor bar / bottom bar
+// ─────────────────────────────────────────────────────────────────────────────
+
+term.on('ready', async () => {
+let view = term.createView();
+let code = await view.prompt("Enter Brainfuck code:");
+let input = await view.prompt("Enter input for Brainfuck code:");
+let output = "";
+let data = [0, 30000];
+let dataPtr = 0;
+let codePtr = 0;
+while (codePtr < code.length) {
+    let cmd = code[codePtr];
+    if (cmd == '>') {
+        dataPtr++;
+    } else if (cmd == '<') {
+        dataPtr--;
+    } else if (cmd == '+') {
+        data[dataPtr] = (data[dataPtr] + 1) % 256;
+    } else if (cmd == '-') {
+        data[dataPtr] = (data[dataPtr] - 1) % 256;
+    } else if (cmd == '.') {
+        output += charAt(data[dataPtr]);
+    } else if (cmd == ',') {
+        if (input.length > 0) {
+            data[dataPtr] = (input[0]) as int;
+            input = input.substr(1);
+        } else {
+            data[dataPtr] = 0;
+        }
+    } else if (cmd == '[') {
+        if (data[dataPtr] == 0) {
+            let Loop = 1;
+            while (Loop > 0) {
+                codePtr++;
+                if (code[codePtr] == '[') Loop++;
+                else if (code[codePtr] == ']') Loop--;
+            }
+        }
+    } else if (cmd == ']') {
+        if (data[dataPtr] != 0) {
+            let Loop = 1;
+            while (Loop > 0) {
+                codePtr--;
+                if (code[codePtr] == ']') Loop++;
+                else if (code[codePtr] == '[') Loop--;
+            }
+        }
+    }
+    codePtr++;
+}
+await view.writeText(0, 0, "Output: " + output, { color: 'green' });
+})

package/novac/examples/math.nv

@@ -0,0 +1,21 @@
+let Tkit = includeKit("libterm");
+let Terminal = Tkit.Terminal;
+let parseExpr = includeKit('kitparse').parseExpr;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Boot Terminal (starts input, enters alt-screen)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const term = Terminal({
+  altScreen: true,
+  mouse:     true,
+  theme:     'dark',
+  logLevel:  'debug',
+});
+
+term.on('ready', async () => {
+let view = term.createView();
+let code = await view.prompt("Enter Math:");
+
+await view.writeText(0, 0, "Output: " + parseExpr(code), { color: 'green' });
+})