Fix list operations and add comprehensive list support - Fix parser to handle (list) as function call instead of list literal - Fix car/cdr to work with both lists and pairs - Fix pair? to recognize lists as pairs - Fix list? to recognize empty list () as list - Add length function for lists and pairs - Fix quote syntax to parse 'a 'b 'c as symbols

Author: TRK95

src/CSE-machine/astToControl.ts

@@ -6,7 +6,6 @@ import {
 } from "../transpiler/types/nodes/scheme-node-types";
 
 export function astToControl(expr: Expression): ControlItem[] {
- 
   if (
     expr instanceof Atomic.NumericLiteral ||
     expr instanceof Atomic.BooleanLiteral ||

src/CSE-machine/instrCreator.ts

@@ -193,7 +193,11 @@ export function createBranchInstr(
 export function createRestoreEnvInstr(env: Environment): RestoreEnvInstr {
   return {
     instrType: InstrType.RESTORE_ENV,
-    srcNode: { type: "StatementSequence", body: [], location: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } } },
+    srcNode: {
+      type: "StatementSequence",
+      body: [],
+      location: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
+    },
     env,
   };
 }

src/CSE-machine/interpreter.ts

@@ -316,18 +316,18 @@ function evaluateInstruction(
         // Apply closure - save current environment and create new one
         const currentEnv = context.environment;
         const newEnv = createBlockEnvironment(operator.env);
-        
+
         // Bind parameters to the new environment
         for (let i = 0; i < operator.params.length; i++) {
           newEnv.define(operator.params[i], args[i] || { type: "nil" });
         }
-        
+
         // Set the new environment for function execution
         context.environment = newEnv;
-        
+
         // Push a marker to restore environment after function execution
         control.push(instr.createRestoreEnvInstr(currentEnv));
-        
+
         // Push function body for execution
         control.push(...operator.body);
       } else if (operator.type === "primitive") {

src/CSE-machine/primitives.ts

@@ -165,17 +165,23 @@ export const primitives: Record<string, (...args: Value[]) => Value> = {
   },
 
   car: (pair: Value) => {
-    if (pair.type !== "pair") {
-      throw new Error("car requires a pair");
+    if (pair.type === "pair") {
+      return pair.car;
+    } else if (pair.type === "list" && pair.elements.length > 0) {
+      return pair.elements[0];
+    } else {
+      throw new Error("car requires a pair or non-empty list");
     }
-    return pair.car;
   },
 
   cdr: (pair: Value) => {
-    if (pair.type !== "pair") {
-      throw new Error("cdr requires a pair");
+    if (pair.type === "pair") {
+      return pair.cdr;
+    } else if (pair.type === "list" && pair.elements.length > 0) {
+      return { type: "list", elements: pair.elements.slice(1) };
+    } else {
+      throw new Error("cdr requires a pair or non-empty list");
     }
-    return pair.cdr;
   },
 
   list: (...args: Value[]) => {
@@ -188,11 +194,11 @@ export const primitives: Record<string, (...args: Value[]) => Value> = {
   },
 
   "pair?": (value: Value) => {
-    return { type: "boolean", value: value.type === "pair" };
+    return { type: "boolean", value: value.type === "pair" || value.type === "list" };
   },
 
   "list?": (value: Value) => {
-    return { type: "boolean", value: value.type === "list" };
+    return { type: "boolean", value: value.type === "list" || value.type === "nil" };
   },
 
   "number?": (value: Value) => {
@@ -210,4 +216,23 @@ export const primitives: Record<string, (...args: Value[]) => Value> = {
   "symbol?": (value: Value) => {
     return { type: "boolean", value: value.type === "symbol" };
   },
+
+  length: (value: Value) => {
+    if (value.type === "list") {
+      return { type: "number", value: value.elements.length };
+    } else if (value.type === "pair") {
+      // Recursively count pairs
+      let count = 0;
+      let current: Value = value;
+      while (current.type === "pair") {
+        count++;
+        current = current.cdr;
+      }
+      return { type: "number", value: count };
+    } else if (value.type === "nil") {
+      return { type: "number", value: 0 };
+    } else {
+      throw new Error("length requires a list or pair");
+    }
+  },
 };

src/CSE-machine/simple-parser.ts

@@ -299,19 +299,14 @@ class SimpleSchemeParser {
       }
     }
 
-    // Check if this is a parameter list (single element that's not a special form)
-    if (elements.length === 1 && elements[0] instanceof Atomic.Identifier) {
-      // This could be a parameter list like (x) in lambda
-      return new Extended.List(location, elements);
-    }
-
-    // Regular function application
+    // Regular function application (including (list) which should be a function call)
     if (elements.length > 0) {
       const operator = elements[0];
       const operands = elements.slice(1);
       return new Atomic.Application(location, operator, operands);
     }
 
+    // Empty list literal
     return new Extended.List(location, elements);
   }
 
@@ -506,6 +501,10 @@ class SimpleSchemeParser {
     if (!quoted) {
       throw new Error("quote requires an expression");
     }
+    // Convert quoted expression to symbol if it's an identifier
+    if (quoted instanceof Atomic.Identifier) {
+      return new Atomic.Symbol(quoted.location, quoted.name);
+    }
     return quoted; // Return the quoted expression directly
   }
 

src/test/12-test-chapter1-features.ts

@@ -323,7 +323,14 @@ function testChapter1Features() {
     },
     {
       code: "(reverse-list (list 1 2 3))",
-      expected: { type: "list", elements: [{ type: "number", value: 3 }, { type: "number", value: 2 }, { type: "number", value: 1 }] },
+      expected: {
+        type: "list",
+        elements: [
+          { type: "number", value: 3 },
+          { type: "number", value: 2 },
+          { type: "number", value: 1 },
+        ],
+      },
       description: "Test reverse-list iteration",
     },
   ];
@@ -395,7 +402,9 @@ function testChapter1Features() {
   console.log("✅ Function composition");
   console.log("✅ Compound functions (functions using other functions)");
   console.log("✅ Linear recursion (factorial, sum-list, count-elements)");
-  console.log("✅ Iteration via tail recursion (factorial-iter, sum-list-iter, reverse-list)");
+  console.log(
+    "✅ Iteration via tail recursion (factorial-iter, sum-list-iter, reverse-list)"
+  );
 }
 
 testChapter1Features();