Module system fix, refactoring, and tests

Author: srad

README.md

@@ -12,6 +12,7 @@ ScriptML is a research project and toy compiler, written in TypeScript, that exp
 - **Recursion and totality checks**  
 - **Dependent function types (Π-types)**  
 - **IO via embedded thunks** that lower to JS functions  
+- **Modules and imports** with qualified names and `open`
 
 The compiler emits either standalone JavaScript or directly evaluates programs.
 
@@ -46,7 +47,7 @@ npm test
 
 ## Language overview
 
-ScriptML has a **typed λ-calculus core** with Nats, Lists, user ADTs, and IO.
+ScriptML has a **typed λ-calculus core** with Nats, Lists, user ADTs, IO, and now **modules**.
 
 ### Basic expressions
 
@@ -116,6 +117,48 @@ in
 length [zero, succ zero, succ (succ zero)]
 ```
 
+---
+
+### Modules
+
+ScriptML supports a lightweight module system.
+
+* A file can begin with `module <Name>` (optional; defaults to the filename).
+* Import another file with `import "path/to/file.sml" as Alias`.
+* Use qualified names like `Math.add`.
+* Use `open <Module>` to bring a module’s values into scope without qualification.
+
+Example module:
+
+```ocaml
+module Math
+
+val add = fun (a: _) -> fun (b: _) -> a + b;
+val sub = fun (a: _) -> fun (b: _) -> a - b;
+```
+
+Use it:
+
+```ocaml
+import "std/math.sml" as Math
+
+println ("3 + 4 = " ^ Math.add 3 4)
+```
+
+Or with `open`:
+
+```ocaml
+import "std/math.sml" as Math
+open Math
+
+println ("3 - 4 = " ^ sub 3 4)
+```
+
+All `val` and `type` decls in a module are exported by default.
+`open` is just syntactic sugar for creating local aliases.
+
+---
+
 ### IO
 
 IO is modeled with thunks (`() => value`) and `bind` / `pure`:
@@ -144,9 +187,14 @@ Builtins provided via `__io`:
 A simplified EBNF for ScriptML:
 
 ```
-program   ::= { decl } term
+program   ::= [ "module" Ident ] { import | decl } [ term ]
+
+import    ::= "import" Str "as" Ident
+            | "open" Ident
 
 decl      ::= "type" Ident { Ident } "=" ctor { "|" ctor }
+            | "val" Ident "=" term ";"
+
 ctor      ::= Ident [ "of" type { "," type } ]
 
 term      ::= let | fun | if | match | expr
@@ -163,6 +211,7 @@ pattern   ::= "zero"
 
 expr      ::= expr atom | atom
 atom      ::= Ident
+            | Ident "." Ident     // qualified variable
             | Int
             | Str
             | "zero"
@@ -172,6 +221,7 @@ atom      ::= Ident
 
 type      ::= type "->" type
             | "Nat"
+            | "Unit"
             | Ident
             | Ident type
             | "(" type ")"
@@ -244,11 +294,11 @@ play 21
   * `lexer.ts`
   * `parser.ts` (Pratt parser)
   * `elab_emit.ts` (elaboration + JS codegen)
-  * `compiler.ts` (top-level driver)
+  * `compiler.ts` (top-level driver, import/module loader)
 * Tests in `__tests__`, goldens in `tests/fixtures`
 
 ---
 
 ## License
 
-MIT
+MIT

__tests__/golden.test.ts

@@ -1,5 +1,5 @@
 import {describe, test, expect} from "@jest/globals";
-import {compileToStandaloneJS, runJSString, fixture, normalizeOut} from "./helpers";
+import { compileToStandaloneJS, runJSString, fixture, normalizeOut, compileFileToStandaloneJS } from "./helpers";
 
 function golden(name: string, answersFile?: string) {
   const src = fixture(`${name}.sml`);
@@ -14,6 +14,35 @@ function golden(name: string, answersFile?: string) {
   expect(actual).toBe(expected);
 }
 
+function goldenEntry(entryRel: string, stdoutFixtureRel: string, stdin?: string) {
+  const js = compileFileToStandaloneJS(entryRel);
+  const res = runJSString(js, stdin);
+  if (res.status !== 0) {
+    throw new Error(
+      `node exited with ${res.status}\nSTDERR:\n${res.stderr}\nSTDOUT:\n${res.stdout}`
+    );
+  }
+  const expected = normalizeOut(fixture(stdoutFixtureRel)).trim();
+  const actual = normalizeOut(res.stdout).trim();
+  expect(actual).toBe(expected);
+}
+
+describe("Modules", () => {
+  test("qualified import: use_math_qualified.sml", () => {
+    goldenEntry(
+      "tests/fixtures/use_math_qualified.sml",
+      "use_math_qualified.stdout"
+    );
+  });
+
+  test("open import: use_math_open.sml", () => {
+    goldenEntry(
+      "tests/fixtures/use_math_open.sml",
+      "use_math_open.stdout"
+    );
+  });
+});
+
 describe("Golden programs", () => {
   test('nim_21.sml', () => {
     golden('nim_21', 'nim_21.answers');

__tests__/helpers.ts

@@ -1,21 +1,29 @@
 import * as fs from "fs";
 import * as path from "path";
-import {spawnSync} from "child_process";
-import {compile} from "../src/compiler";
+import { spawnSync } from "child_process";
+import { compile, compileFile } from "../src/compiler";
 
-/** Compile SML to a standalone JS string (with embedded __io runtime). */
+/** Compile SML source text to a standalone JS string (with embedded __io runtime). */
 export function compileToStandaloneJS(src: string): string {
   return String(compile(src, "js"));
 }
 
+/** Compile an ENTRY FILE (resolving imports/open) to a standalone JS string. */
+export function compileFileToStandaloneJS(entryRelOrAbs: string): string {
+  const entry = path.isAbsolute(entryRelOrAbs)
+    ? entryRelOrAbs
+    : path.resolve(process.cwd(), entryRelOrAbs);
+  return String(compileFile(entry, "js"));
+}
+
 const ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g; // robust ANSI escape matcher
 export const normalizeOut = (s: string) =>
   s.replace(ANSI_RE, "").replace(/\r\n/g, "\n");
 
 /** Run a standalone JS string with Node, capturing stdout/stderr as strings. */
 export function runJSString(js: string, stdin?: string) {
   const tmp = path.join(process.cwd(), "tests", ".tmp");
-  fs.mkdirSync(tmp, {recursive: true});
+  fs.mkdirSync(tmp, { recursive: true });
   const file = path.join(
     tmp,
     `prog_${Date.now()}_${Math.random().toString(36).slice(2)}.js`