rename csep machine to cset machine

Author: s-kybound

src/alt-langs/scheme/scm-slang

@@ -38,8 +38,8 @@ import { makeWrapper } from './utils/makeWrapper'
 import * as operators from './utils/operators'
 import { stringify } from './utils/stringify'
 import { schemeVisualise } from './alt-langs/scheme/scheme-mapper'
-import { csep_eval } from './cse-machine/scheme-macros'
-import { Pattern } from './cse-machine/interpreter'
+import { cset_eval } from './cse-machine/scheme-macros'
+import { Transformers } from './cse-machine/interpreter'
 
 export class LazyBuiltIn {
   func: (...arg0: any) => any
@@ -119,7 +119,7 @@ const createEmptyRuntime = () => ({
   nodes: [],
   control: null,
   stash: null,
-  patterns: new Pattern(),
+  transformers: new Transformers(),
   objectCount: 0,
   envSteps: -1,
   envStepsTotal: 0,
@@ -455,7 +455,7 @@ export const importBuiltins = (context: Context, externalBuiltIns: CustomBuiltIn
       case Chapter.FULL_SCHEME:
         // Introduction to eval
         // eval metaprocedure
-        defineBuiltin(context, '$scheme_ZXZhbA$61$$61$(xs)', csep_eval)
+        defineBuiltin(context, '$scheme_ZXZhbA$61$$61$(xs)', cset_eval)
 
       case Chapter.SCHEME_4:
         // Introduction to call/cc

src/createContext.ts

@@ -5,7 +5,7 @@ import { parse } from '../../parser/parser'
 import { runCodeInSource } from '../../runner'
 import { Chapter, RecursivePartial } from '../../types'
 import { stripIndent } from '../../utils/formatters'
-import { Control, Pattern, Stash, generateCSEMachineStateStream } from '../interpreter'
+import { Control, Transformers, Stash, generateCSEMachineStateStream } from '../interpreter'
 
 const getContextFrom = async (code: string, steps?: number) => {
   const context = mockContext(Chapter.SOURCE_4)
@@ -24,13 +24,13 @@ const evaluateCode = (code: string) => {
   context.runtime.isRunning = true
   context.runtime.control = new Control(program as es.Program)
   context.runtime.stash = new Stash()
-  context.runtime.patterns = new Pattern()
+  context.runtime.transformers = new Transformers()
 
   const CSEState = generateCSEMachineStateStream(
     context,
     context.runtime.control,
     context.runtime.stash,
-    context.runtime.patterns,
+    context.runtime.transformers,
     options.envSteps ?? -1,
     options.stepLimit ?? -1,
     options.isPrelude

src/cse-machine/__tests__/cse-machine-runtime-context.ts

@@ -1,7 +1,7 @@
 import { Chapter, Variant } from '../../types'
 import { expectParsedError, expectResult } from '../../utils/testing'
 
-// CSEP tests for Scheme
+// CSET tests for Scheme
 const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
 
 test('eval of numbers', () => {

src/cse-machine/__tests__/csep-machine-eval.ts renamed to src/cse-machine/__tests__/cset-machine-eval.ts

@@ -1,7 +1,7 @@
 import { Chapter, Variant } from '../../types'
 import { expectParsedError, expectResult } from '../../utils/testing'
 
-// CSEP tests for Scheme Macros
+// CSET tests for Scheme Macros
 const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
 
 test('definition of a macro', () => {

src/cse-machine/__tests__/csep-machine-macros.ts renamed to src/cse-machine/__tests__/cset-machine-macros.ts

@@ -10,7 +10,7 @@ import {
 } from '../cse-machine/utils'
 import { Context, Environment, StatementSequence, Value } from '../types'
 import * as ast from '../utils/ast/astCreator'
-import { Control, Pattern, Stash, generateCSEMachineStateStream } from './interpreter'
+import { Control, Transformers, Stash, generateCSEMachineStateStream } from './interpreter'
 import { envInstr } from './instrCreator'
 
 const closureToJS = (value: Closure, context: Context) => {
@@ -39,12 +39,12 @@ const closureToJS = (value: Closure, context: Context) => {
     // The call expression won't create one as there is only one item in the control.
     newContext.runtime.control.push(envInstr(currentEnvironment(context), node), node)
     newContext.runtime.stash = new Stash()
-    newContext.runtime.patterns = context.runtime.patterns
+    newContext.runtime.transformers = context.runtime.transformers
     const gen = generateCSEMachineStateStream(
       newContext,
       newContext.runtime.control,
       newContext.runtime.stash,
-      newContext.runtime.patterns as Pattern,
+      newContext.runtime.transformers as Transformers,
       -1,
       -1
     )

src/cse-machine/closure.ts

@@ -174,10 +174,10 @@ export class Stash extends Stack<Value> {
 }
 
 /**
- * The P component is a dictionary of mappings from syntax names to
+ * The T component is a dictionary of mappings from syntax names to
  * their corresponding syntax rule transformers (patterns).
  */
-export class Pattern {
+export class Transformers {
   private items: Map<string, Transformer[]>
   public constructor() {
     this.items = new Map<string, Transformer[]>()
@@ -218,12 +218,14 @@ export function evaluate(program: es.Program, context: Context, options: IOption
     context.runtime.isRunning = true
     context.runtime.control = new Control(program)
     context.runtime.stash = new Stash()
-    context.runtime.patterns = context.runtime.patterns ? context.runtime.patterns : new Pattern()
+    context.runtime.transformers = context.runtime.transformers
+      ? context.runtime.transformers
+      : new Transformers()
     return runCSEMachine(
       context,
       context.runtime.control,
       context.runtime.stash,
-      context.runtime.patterns,
+      context.runtime.transformers,
       options.envSteps,
       options.stepLimit,
       options.isPrelude
@@ -250,7 +252,7 @@ export function resumeEvaluate(context: Context) {
       context,
       context.runtime.control!,
       context.runtime.stash!,
-      context.runtime.patterns as Pattern,
+      context.runtime.transformers as Transformers,
       -1,
       -1
     )
@@ -331,7 +333,7 @@ function runCSEMachine(
   context: Context,
   control: Control,
   stash: Stash,
-  patterns: Pattern,
+  transformers: Transformers,
   envSteps: number,
   stepLimit: number,
   isPrelude: boolean = false
@@ -340,7 +342,7 @@ function runCSEMachine(
     context,
     control,
     stash,
-    patterns,
+    transformers,
     envSteps,
     stepLimit,
     isPrelude
@@ -358,7 +360,7 @@ export function* generateCSEMachineStateStream(
   context: Context,
   control: Control,
   stash: Stash,
-  patterns: Pattern,
+  transformers: Transformers,
   envSteps: number,
   stepLimit: number,
   isPrelude: boolean = false
@@ -421,7 +423,7 @@ export function* generateCSEMachineStateStream(
       cmdEvaluators[command.instrType](command, context, control, stash, isPrelude)
     } else {
       // this is a scheme value
-      schemeEval(command, context, control, stash, patterns, isPrelude)
+      schemeEval(command, context, control, stash, transformers, isPrelude)
     }
 
     // Push undefined into the stack if both control and stash is empty

src/cse-machine/interpreter.ts

@@ -4,7 +4,7 @@ import { List } from '../stdlib/list'
 import { _Symbol } from '../alt-langs/scheme/scm-slang/src/stdlib/base'
 import { is_number, SchemeNumber } from '../alt-langs/scheme/scm-slang/src/stdlib/core-math'
 import { Context } from '..'
-import { Control, Pattern, Stash } from './interpreter'
+import { Control, Transformers, Stash } from './interpreter'
 import { getVariable, handleRuntimeError } from './utils'
 import {
   Transformer,
@@ -42,10 +42,10 @@ export class Eval extends Function {
   }
 }
 
-export const csep_eval = Eval.get()
+export const cset_eval = Eval.get()
 
 export function isEval(value: any): boolean {
-  return value === csep_eval
+  return value === cset_eval
 }
 
 // helper function to check if a value is a list.
@@ -84,15 +84,15 @@ export function schemeEval(
   context: Context,
   control: Control,
   stash: Stash,
-  patterns: Pattern,
+  transformers: Transformers,
   isPrelude: boolean
 ) {
   // scheme CSE machine will only ever encounter
   // lists or primitives like symbols, booleans or strings.
   // if its a list, we can parse the list and evaluate each item as necessary
   // if its a symbol, we can look up the symbol in the environment.
   // for either of these operations, if our list matches some pattern in
-  // the P component, then we can apply the corresponding rule.
+  // the T component, then we can apply the corresponding rule.
 
   // if its a number, boolean, or string, we can just shift the value
   // onto the stash.
@@ -109,14 +109,14 @@ export function schemeEval(
     // it should match some symbol "define", "set", "lambda", etc...
     // or if it doesn't match any of these, then it is a function call.
     if (elem instanceof _Symbol) {
-      // check if elem matches any defined syntax in the P component.
+      // check if elem matches any defined syntax in the T component.
       // if it does, then apply the corresponding rule.
-      if (patterns.hasPattern(elem.sym)) {
+      if (transformers.hasPattern(elem.sym)) {
         // get the relevant transformers
-        const transformers: Transformer[] = patterns.getPattern(elem.sym)
+        const transformerList: Transformer[] = transformers.getPattern(elem.sym)
 
         // find the first matching transformer
-        for (const transformer of transformers) {
+        for (const transformer of transformerList) {
           // check if the transformer matches the list
           try {
             if (match(command, transformer.pattern, transformer.literals)) {
@@ -468,14 +468,14 @@ export function schemeEval(
           const rules = syntaxRulesList.slice(2)
           // rules are set as a list of patterns and templates.
           // we need to convert these into transformers.
-          const transformers: Transformer[] = rules.map(rule => {
+          const transformerList: Transformer[] = rules.map(rule => {
             const ruleList = flattenList(rule)
             const pattern = ruleList[0]
             const template = ruleList[1]
             return new Transformer(literals, pattern, template)
           })
           // now we can add the transformers to the patterns component.
-          patterns.addPattern(syntaxName.sym, transformers)
+          transformers.addPattern(syntaxName.sym, transformerList)
           return
         case 'syntax-rules':
           // syntax-rules is a special form that is used to define
@@ -503,12 +503,12 @@ export function schemeEval(
     control.push(appln as es.CallExpression)
     return
   } else if (command instanceof _Symbol) {
-    if (patterns.hasPattern(command.sym)) {
+    if (transformers.hasPattern(command.sym)) {
       // get the relevant transformers
-      const transformers: Transformer[] = patterns.getPattern(command.sym)
+      const transformerList: Transformer[] = transformers.getPattern(command.sym)
 
       // find the first matching transformer
-      for (const transformer of transformers) {
+      for (const transformer of transformerList) {
         // check if the transformer matches the list
         try {
           if (match(command, transformer.pattern, transformer.literals)) {

src/cse-machine/scheme-macros.ts

@@ -10,7 +10,7 @@ import * as es from 'estree'
 
 import { EnvTree } from './createContext'
 import Heap from './cse-machine/heap'
-import { Control, Pattern, Stash } from './cse-machine/interpreter'
+import { Control, Stash, Transformers } from './cse-machine/interpreter'
 import type { ModuleFunctions } from './modules/moduleTypes'
 import { Representation } from './alt-langs/mapper'
 
@@ -146,7 +146,7 @@ export interface Context<T = any> {
 
   /** Runtime Specific state */
   runtime: {
-    patterns?: Pattern
+    transformers?: Transformers
     break: boolean
     debuggerOn: boolean
     isRunning: boolean