Add stepper functionality with lambda and user-defined function support

Author: TRK95

src/index.ts

@@ -29,6 +29,9 @@ export { initialise } from "./conductor/runner/util/initialise";
 export * from "./utils/encoder-visitor";
 export { unparse } from "./utils/reverse_parser";
 
+// Export tracer functionality
+export { stepExpression } from "./tracer/stepper";
+
 const JS_KEYWORDS: string[] = [
   "break",
   "case",

src/tracer/generator.ts

@@ -0,0 +1,72 @@
+import { StepperBaseNode } from './interface';
+import { StepperLiteral } from './nodes/Expression/Literal';
+import { StepperBinaryExpression } from './nodes/Expression/BinaryExpression';
+import { StepperIdentifier } from './nodes/Expression/Identifier';
+import { StepperFunctionApplication } from './nodes/Expression/FunctionApplication';
+import { StepperLambdaExpression } from './nodes/Expression/LambdaExpression';
+import { StepperProgram } from './nodes/Program';
+
+const undefinedNode = new StepperLiteral('undefined');
+
+// Helper function to convert nodes without circular dependency
+function convertNode(node: any): StepperBaseNode {
+  const nodeType = node.constructor.name;
+  
+  switch (nodeType) {
+    case 'NumericLiteral':
+    case 'BooleanLiteral':
+    case 'StringLiteral':
+      return StepperLiteral.create(node);
+    case 'Identifier':
+      return StepperIdentifier.create(node);
+    case 'Application':
+      return new StepperFunctionApplication(
+        convertNode(node.operator),
+        node.operands.map(convertNode)
+      );
+    case 'Lambda':
+      return new StepperLambdaExpression(
+        node.params || [],
+        convertNode(node.body)
+      );
+    case 'Sequence':
+      return new StepperProgram(
+        node.expressions.map(convertNode)
+      );
+    default:
+      return undefinedNode;
+  }
+}
+
+const nodeConverters: { [Key: string]: (node: any) => StepperBaseNode } = {
+  NumericLiteral: (node: any) => StepperLiteral.create(node),
+  BooleanLiteral: (node: any) => StepperLiteral.create(node),
+  StringLiteral: (node: any) => StepperLiteral.create(node),
+  Identifier: (node: any) => StepperIdentifier.create(node),
+  Application: (node: any) => convertNode(node),
+  Lambda: (node: any) => convertNode(node),
+  Sequence: (node: any) => convertNode(node)
+};
+
+export function convert(node: any): StepperBaseNode {
+  const converter = nodeConverters[node.type as keyof typeof nodeConverters];
+  return converter ? converter(node) : undefinedNode;
+}
+
+export function explain(node: StepperBaseNode): string {
+  // Generate explanation based on node type
+  switch (node.type) {
+    case 'Literal':
+      return `Evaluated to literal value: ${node.toString()}`;
+    case 'BinaryExpression':
+      return `Evaluated binary expression: ${node.toString()}`;
+    case 'Identifier':
+      return `Variable reference: ${node.toString()}`;
+    case 'FunctionApplication':
+      return `Function application: ${node.toString()}`;
+    case 'LambdaExpression':
+      return `Lambda expression: ${node.toString()}`;
+    default:
+      return `Processed ${node.type}`;
+  }
+}

src/tracer/index.ts

@@ -0,0 +1,23 @@
+import { StepperBaseNode } from './interface';
+
+export let redex: { preRedex: StepperBaseNode[]; postRedex: StepperBaseNode[] } = {
+  preRedex: [],
+  postRedex: []
+};
+
+export interface Marker {
+  redex?: StepperBaseNode | null;
+  redexType?: 'beforeMarker' | 'afterMarker';
+  explanation?: string;
+}
+
+export interface IStepperPropContents {
+  ast: StepperBaseNode;
+  markers: Marker[];
+}
+
+// Export all modules
+export * from './generator';
+export * from './steppers';
+export * from './stepper';
+export * from './nodes';

src/tracer/interface.ts

@@ -0,0 +1,14 @@
+import { StepperExpression, StepperPattern } from './nodes';
+
+export interface StepperBaseNode {
+  type: string;
+  isContractible(): boolean;
+  isOneStepPossible(): boolean;
+  contract(): StepperBaseNode;
+  oneStep(): StepperBaseNode;
+  substitute(id: StepperPattern, value: StepperExpression): StepperBaseNode;
+  freeNames(): string[];
+  allNames(): string[];
+  rename(before: string, after: string): StepperBaseNode;
+  toString(): string;
+}

src/tracer/nodes/Expression/BinaryExpression.ts

@@ -0,0 +1,108 @@
+import { StepperBaseNode } from '../../interface';
+import { StepperExpression, StepperPattern } from '../index';
+
+export class StepperBinaryExpression implements StepperBaseNode {
+  type = 'BinaryExpression';
+  operator: string;
+  left: StepperBaseNode;
+  right: StepperBaseNode;
+
+  constructor(operator: string, left: StepperBaseNode, right: StepperBaseNode) {
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+  }
+
+  static create(node: any): StepperBinaryExpression {
+    // This would need to be implemented based on how Scheme binary expressions are parsed
+    // For now, creating a basic implementation
+    return new StepperBinaryExpression(
+      node.operator || '+',
+      node.left || { type: 'Literal', value: 0 },
+      node.right || { type: 'Literal', value: 0 }
+    );
+  }
+
+  isContractible(): boolean {
+    return this.left.isContractible() && this.right.isContractible();
+  }
+
+  isOneStepPossible(): boolean {
+    return !this.left.isContractible() || !this.right.isContractible();
+  }
+
+  contract(): StepperBaseNode {
+    if (!this.isContractible()) {
+      throw new Error('Cannot contract non-contractible expression');
+    }
+    
+    // Evaluate the binary expression
+    const leftValue = this.left.contract();
+    const rightValue = this.right.contract();
+    
+    if (leftValue.type === 'Literal' && rightValue.type === 'Literal') {
+      const left = (leftValue as any).value;
+      const right = (rightValue as any).value;
+      let result: any;
+      
+      switch (this.operator) {
+        case '+':
+          result = left + right;
+          break;
+        case '-':
+          result = left - right;
+          break;
+        case '*':
+          result = left * right;
+          break;
+        case '/':
+          result = left / right;
+          break;
+        default:
+          throw new Error(`Unknown operator: ${this.operator}`);
+      }
+      
+      return { type: 'Literal', value: result, raw: String(result), toString: () => String(result) } as any;
+    }
+    
+    return this;
+  }
+
+  oneStep(): StepperBaseNode {
+    if (!this.left.isContractible()) {
+      return new StepperBinaryExpression(this.operator, this.left.oneStep(), this.right);
+    }
+    if (!this.right.isContractible()) {
+      return new StepperBinaryExpression(this.operator, this.left, this.right.oneStep());
+    }
+    return this.contract();
+  }
+
+  substitute(id: StepperPattern, value: StepperExpression): StepperBaseNode {
+    return new StepperBinaryExpression(
+      this.operator,
+      this.left.substitute(id, value),
+      this.right.substitute(id, value)
+    );
+  }
+
+  freeNames(): string[] {
+    return [...this.left.freeNames(), ...this.right.freeNames()];
+  }
+
+  allNames(): string[] {
+    return [...this.left.allNames(), ...this.right.allNames()];
+  }
+
+  rename(before: string, after: string): StepperBaseNode {
+    return new StepperBinaryExpression(
+      this.operator,
+      this.left.rename(before, after),
+      this.right.rename(before, after)
+    );
+  }
+
+  toString(): string {
+    return `(${this.operator} ${this.left.toString()} ${this.right.toString()})`;
+  }
+}

src/tracer/nodes/Expression/FunctionApplication.ts

@@ -0,0 +1,105 @@
+import { StepperBaseNode } from '../../interface';
+import { StepperExpression, StepperPattern } from '../index';
+
+export class StepperFunctionApplication implements StepperBaseNode {
+  type = 'FunctionApplication';
+  operator: StepperBaseNode;
+  operands: StepperBaseNode[];
+
+  constructor(operator: StepperBaseNode, operands: StepperBaseNode[]) {
+    this.operator = operator;
+    this.operands = operands;
+  }
+
+  static create(node: any): StepperFunctionApplication {
+    // This will be handled by the convertNode function in generator.ts
+    return new StepperFunctionApplication(
+      node.operator,
+      node.operands
+    );
+  }
+
+  isContractible(): boolean {
+    // Check if operator is a lambda and all operands are literals
+    if (this.operator.type === 'LambdaExpression') {
+      return this.operands.every(op => op.isContractible());
+    }
+    return false;
+  }
+
+  isOneStepPossible(): boolean {
+    // Can step if any operand is not contractible, or if operator is lambda and all operands are contractible
+    return this.operands.some(op => !op.isContractible()) || this.isContractible();
+  }
+
+  contract(): StepperBaseNode {
+    if (!this.isContractible()) {
+      throw new Error('Cannot contract non-contractible expression');
+    }
+    
+    // Perform beta-reduction for lambda applications
+    if (this.operator.type === 'LambdaExpression') {
+      const lambda = this.operator as any;
+      let body = lambda.body;
+      
+      // Substitute parameters with arguments
+      for (let i = 0; i < lambda.params.length && i < this.operands.length; i++) {
+        const param = lambda.params[i];
+        const arg = this.operands[i];
+        body = body.substitute(param, arg);
+      }
+      
+      return body;
+    }
+    
+    return this;
+  }
+
+  oneStep(): StepperBaseNode {
+    // First, step any non-contractible operands
+    const steppedOperands = this.operands.map(op => 
+      op.isContractible() ? op : op.oneStep()
+    );
+    
+    // If all operands are now contractible and operator is lambda, contract
+    if (this.operator.type === 'LambdaExpression' && 
+        steppedOperands.every(op => op.isContractible())) {
+      return this.contract();
+    }
+    
+    return new StepperFunctionApplication(this.operator, steppedOperands);
+  }
+
+  substitute(id: StepperPattern, value: StepperExpression): StepperBaseNode {
+    return new StepperFunctionApplication(
+      this.operator.substitute(id, value),
+      this.operands.map(op => op.substitute(id, value))
+    );
+  }
+
+  freeNames(): string[] {
+    return [
+      ...this.operator.freeNames(),
+      ...this.operands.flatMap(op => op.freeNames())
+    ];
+  }
+
+  allNames(): string[] {
+    return [
+      ...this.operator.allNames(),
+      ...this.operands.flatMap(op => op.allNames())
+    ];
+  }
+
+  rename(before: string, after: string): StepperBaseNode {
+    return new StepperFunctionApplication(
+      this.operator.rename(before, after),
+      this.operands.map(op => op.rename(before, after))
+    );
+  }
+
+  toString(): string {
+    return `(${this.operator.toString()} ${this.operands.map(op => op.toString()).join(' ')})`;
+  }
+}
+

src/tracer/nodes/Expression/Identifier.ts

@@ -0,0 +1,57 @@
+import { StepperBaseNode } from '../../interface';
+import { StepperExpression, StepperPattern } from '../index';
+
+export class StepperIdentifier implements StepperBaseNode {
+  type = 'Identifier';
+  name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  static create(node: any): StepperIdentifier {
+    return new StepperIdentifier(node.name);
+  }
+
+  isContractible(): boolean {
+    return true;
+  }
+
+  isOneStepPossible(): boolean {
+    return false;
+  }
+
+  contract(): StepperBaseNode {
+    return this;
+  }
+
+  oneStep(): StepperBaseNode {
+    return this;
+  }
+
+  substitute(id: StepperPattern, value: StepperExpression): StepperBaseNode {
+    if (this.name === id.name) {
+      return value;
+    }
+    return this;
+  }
+
+  freeNames(): string[] {
+    return [this.name];
+  }
+
+  allNames(): string[] {
+    return [this.name];
+  }
+
+  rename(before: string, after: string): StepperBaseNode {
+    if (this.name === before) {
+      return new StepperIdentifier(after);
+    }
+    return this;
+  }
+
+  toString(): string {
+    return this.name;
+  }
+}