Independent scheme

.gitignore

@@ -80,7 +80,6 @@ typings/
 
 # Nuxt.js build / generate output
 .nuxt
-dist
 
 # Gatsby files
 .cache/
@@ -91,6 +90,9 @@ dist
 # vuepress build output
 .vuepress/dist
 
+# Build output
+dist/
+
 # Serverless directories
 .serverless/
 

.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

package.json

@@ -12,7 +12,8 @@
     "type": "git",
     "url": "git+https://github.com/source-academy/scm-slang.git"
   },
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bugs": {
     "url": "https://github.com/source-academy/scm-slang/issues"
   },
@@ -25,6 +26,8 @@
     "js-base64": "^3.7.7"
   },
   "scripts": {
+    "build": "rollup -c --bundleConfigAsCjs",
+    "start": "npm run build && node dist/index.js",
     "build-libs": "npx ts-node ./src/compile-libs.ts",
     "test": "jest",
     "test-coverage": "jest --coverage",
@@ -35,22 +38,28 @@
   },
   "meta": {},
   "devDependencies": {
-    "@babel/preset-env": "^7.28.0",
-    "@types/jest": "^30.0.0",
+    "@babel/preset-env": "^7.27.2",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.12",
     "@types/node": "^22.15.30",
     "@typescript-eslint/eslint-plugin": "^6.4.0",
-    "babel-jest": "^30.0.5",
+    "babel-jest": "^29.7.0",
     "escodegen": "^2.1.0",
     "eslint": "^8.57.1",
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
     "eslint-plugin-promise": "^6.6.0",
     "husky": "^9.1.7",
-    "jest": "^30.0.4",
-    "prettier": "^3.6.2",
+    "jest": "^29.7.0",
+    "jest-util": "^30.0.5",
+    "prettier": "^3.5.3",
+    "rollup": "^4.38.0",
     "source-map": "^0.7.4",
-    "ts-jest": "^29.4.0",
-    "typescript": "*"
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.4.5"
   }
 }

rollup.config.js

@@ -0,0 +1,33 @@
+import resolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import typescript from "@rollup/plugin-typescript";
+
+/**
+ * @type {import('rollup').RollupOptions}
+ */
+const config = {
+  input: "src/index.ts",
+  output: {
+    file: "dist/index.js",
+    format: "umd",
+    name: "ScmSlangRunner",
+    sourcemap: false,
+    globals: {},
+  },
+  plugins: [
+    resolve({
+      preferBuiltins: false,
+      browser: true,
+    }),
+    commonjs({
+      include: "node_modules/**",
+      transformMixedEsModules: true,
+      requireReturnsDefault: "auto",
+    }),
+    typescript({
+      tsconfig: "./tsconfig.json",
+    }),
+  ],
+};
+
+export default config;

src/CSE-machine/astToControl.ts

@@ -0,0 +1,39 @@
+import { ControlItem } from "./control";
+import {
+  Expression,
+  Atomic,
+  Extended,
+} from "../transpiler/types/nodes/scheme-node-types";
+
+export function astToControl(expr: Expression): ControlItem[] {
+  if (
+    expr instanceof Atomic.NumericLiteral ||
+    expr instanceof Atomic.BooleanLiteral ||
+    expr instanceof Atomic.StringLiteral ||
+    expr instanceof Atomic.Symbol ||
+    expr instanceof Atomic.Identifier ||
+    expr instanceof Atomic.Lambda ||
+    expr instanceof Atomic.Application ||
+    expr instanceof Atomic.Definition ||
+    expr instanceof Atomic.Reassignment ||
+    expr instanceof Atomic.Conditional ||
+    expr instanceof Atomic.Sequence ||
+    expr instanceof Atomic.Pair ||
+    expr instanceof Atomic.Nil ||
+    expr instanceof Atomic.Import ||
+    expr instanceof Atomic.Export ||
+    expr instanceof Atomic.Vector ||
+    expr instanceof Atomic.DefineSyntax ||
+    expr instanceof Atomic.SyntaxRules ||
+    expr instanceof Extended.FunctionDefinition ||
+    expr instanceof Extended.Let ||
+    expr instanceof Extended.Cond ||
+    expr instanceof Extended.List ||
+    expr instanceof Extended.Begin ||
+    expr instanceof Extended.Delay
+  ) {
+    return [expr];
+  }
+  console.log("DEBUG expr:", expr);
+  throw new Error(`Unhandled expr type: ${expr.constructor.name}`);
+}

src/CSE-machine/closure.ts

@@ -0,0 +1,26 @@
+// closure.ts
+import { Expression } from "../transpiler/types/nodes/scheme-node-types";
+import { Environment } from "./environment";
+
+export class Closure {
+  readonly type = "Closure";
+  readonly params: string[];
+  readonly body: Expression[];
+  readonly env: Environment;
+  readonly declaredName?: string;
+  readonly srcNode?: Expression; // AST node for debugging
+
+  constructor(
+    params: string[],
+    body: Expression[],
+    env: Environment,
+    declaredName?: string,
+    srcNode?: Expression
+  ) {
+    this.params = params;
+    this.body = body;
+    this.env = env;
+    this.declaredName = declaredName;
+    this.srcNode = srcNode;
+  }
+}

src/CSE-machine/complex.ts

@@ -0,0 +1,151 @@
+// Complex number implementation for Scheme
+// Based on py-slang PyComplexNumber
+
+export class SchemeComplexNumber {
+  public real: number;
+  public imag: number;
+
+  constructor(real: number, imag: number) {
+    this.real = real;
+    this.imag = imag;
+  }
+
+  public static fromNumber(value: number): SchemeComplexNumber {
+    return new SchemeComplexNumber(value, 0);
+  }
+
+  public static fromString(str: string): SchemeComplexNumber {
+    // Handle Scheme complex number syntax: 3+4i, 1-2i, 5i
+    if (!/[iI]/.test(str)) {
+      const realVal = Number(str);
+      if (isNaN(realVal)) {
+        throw new Error(`Invalid complex string: ${str}`);
+      }
+      return new SchemeComplexNumber(realVal, 0);
+    }
+
+    const lower = str.toLowerCase();
+    if (lower.endsWith("i")) {
+      const numericPart = str.substring(0, str.length - 1);
+
+      // Handle purely imaginary: i, +i, -i
+      if (numericPart === "" || numericPart === "+") {
+        return new SchemeComplexNumber(0, 1);
+      } else if (numericPart === "-") {
+        return new SchemeComplexNumber(0, -1);
+      }
+
+      // Check if it's purely imaginary: 5i
+      const imagVal = Number(numericPart);
+      if (!isNaN(imagVal)) {
+        return new SchemeComplexNumber(0, imagVal);
+      }
+
+      // Handle complex with both real and imaginary parts: 3+4i, 1-2i
+      const match = numericPart.match(
+        /^([\+\-]?\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?)([\+\-]\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?)$/
+      );
+      if (match) {
+        const realPart = Number(match[1]);
+        const imagPart = Number(match[2]);
+        return new SchemeComplexNumber(realPart, imagPart);
+      }
+    }
+
+    throw new Error(`Invalid complex string: ${str}`);
+  }
+
+  public static fromValue(
+    value: number | string | SchemeComplexNumber
+  ): SchemeComplexNumber {
+    if (value instanceof SchemeComplexNumber) {
+      return value;
+    } else if (typeof value === "number") {
+      return SchemeComplexNumber.fromNumber(value);
+    } else if (typeof value === "string") {
+      return SchemeComplexNumber.fromString(value);
+    } else {
+      throw new Error(`Cannot convert ${typeof value} to complex number`);
+    }
+  }
+
+  // Arithmetic operations
+  public add(other: SchemeComplexNumber): SchemeComplexNumber {
+    return new SchemeComplexNumber(
+      this.real + other.real,
+      this.imag + other.imag
+    );
+  }
+
+  public sub(other: SchemeComplexNumber): SchemeComplexNumber {
+    return new SchemeComplexNumber(
+      this.real - other.real,
+      this.imag - other.imag
+    );
+  }
+
+  public mul(other: SchemeComplexNumber): SchemeComplexNumber {
+    // (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
+    const real = this.real * other.real - this.imag * other.imag;
+    const imag = this.real * other.imag + this.imag * other.real;
+    return new SchemeComplexNumber(real, imag);
+  }
+
+  public div(other: SchemeComplexNumber): SchemeComplexNumber {
+    // (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
+    const denominator = other.real * other.real + other.imag * other.imag;
+    if (denominator === 0) {
+      throw new Error("Division by zero");
+    }
+    const real =
+      (this.real * other.real + this.imag * other.imag) / denominator;
+    const imag =
+      (this.imag * other.real - this.real * other.imag) / denominator;
+    return new SchemeComplexNumber(real, imag);
+  }
+
+  public negate(): SchemeComplexNumber {
+    return new SchemeComplexNumber(-this.real, -this.imag);
+  }
+
+  // Comparison (only for equality)
+  public equals(other: SchemeComplexNumber): boolean {
+    return this.real === other.real && this.imag === other.imag;
+  }
+
+  // Magnitude
+  public abs(): number {
+    return Math.sqrt(this.real * this.real + this.imag * this.imag);
+  }
+
+  // String representation
+  public toString(): string {
+    if (this.imag === 0) {
+      return this.real.toString();
+    } else if (this.real === 0) {
+      if (this.imag === 1) return "i";
+      if (this.imag === -1) return "-i";
+      return `${this.imag}i`;
+    } else {
+      const imagPart =
+        this.imag === 1
+          ? "i"
+          : this.imag === -1
+            ? "-i"
+            : this.imag > 0
+              ? `+${this.imag}i`
+              : `${this.imag}i`;
+      return `${this.real}${imagPart}`;
+    }
+  }
+
+  // Convert to JavaScript number (only if purely real)
+  public toNumber(): number {
+    if (this.imag !== 0) {
+      throw new Error(
+        "Cannot convert complex number with imaginary part to real number"
+      );
+    }
+    return this.real;
+  }
+}