kei-lisp 2.2.0 → 2.3.0

package/dist/index.d.cts

@@ -622,6 +622,11 @@ declare class Evaluator extends Object {
    * Lisp-name to method-name dispatch map for special forms.
    */
   static readonly buildInFunctions: Map<InterpretedSymbol, string>;
+  /**
+   * Marker symbol stored as the car of the Cons that represents a macro binding,
+   * distinguishing macros from ordinary `lambda` closures in the environment.
+   */
+  static readonly macroMarker: InterpretedSymbol;
   /**
    * The variable binding environment used during evaluation.
    */
@@ -694,6 +699,54 @@ declare class Evaluator extends Object {
    * @return the function name symbol
    */
   defun(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `defmacro` special form. Defines a macro: a
+   * transformer whose body receives its arguments unevaluated and returns a
+   * form that is then evaluated in the caller's environment.
+   * @param aCons the argument Cons containing the macro name, parameter list, and body
+   * @return the macro name symbol
+   */
+  defmacro(aCons: Cons): LispValue;
+  /**
+   * Returns the macro transformer (a lambda Cons) bound to the given symbol, or
+   * null when the symbol is not bound to a macro. Special-form symbols are never
+   * treated as macros.
+   * @param car the operator position of a call form
+   * @return the macro's lambda Cons, or null
+   */
+  lookupMacro(car: LispValue): Cons | null;
+  /**
+   * Expands a macro call exactly once by applying its transformer to the
+   * unevaluated argument forms in the macro's captured environment.
+   * @param form the call form whose car names the macro
+   * @param macroLambda the macro's transformer lambda Cons
+   * @return the expansion form
+   */
+  expandMacro1(form: Cons, macroLambda: Cons): LispValue;
+  /**
+   * Expands a macro call once and evaluates the resulting form in the current
+   * environment.
+   * @param form the call form whose car names the macro
+   * @param macroLambda the macro's transformer lambda Cons
+   * @return the result of evaluating the expansion
+   */
+  evalMacroCall(form: Cons, macroLambda: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `macroexpand-1` special form. Evaluates its
+   * argument to obtain a form and, when that form is a macro call, expands it
+   * exactly once without evaluating the result.
+   * @param aCons the argument Cons whose car evaluates to the form to expand
+   * @return the once-expanded form, or the form unchanged when it is not a macro call
+   */
+  macroexpand_1(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `macroexpand` special form. Evaluates its
+   * argument to obtain a form and repeatedly expands it until the result is no
+   * longer a macro call, without evaluating the result.
+   * @param aCons the argument Cons whose car evaluates to the form to expand
+   * @return the fully expanded form
+   */
+  macroexpand(aCons: Cons): LispValue;
   /**
    * Implementation of the Lisp `do` special form (parallel binding update).
    * @param aCons the argument Cons containing bindings, termination clause, and body
@@ -852,6 +905,49 @@ declare class Evaluator extends Object {
    * @return the quoted form
    */
   quote(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `quasiquote` (`` ` ``) special form. Returns the
+   * template with every `unquote` (`,`) and `unquote-splicing` (`,@`) at the
+   * matching nesting level replaced by the evaluation of its operand. Nested
+   * quasiquotes increase the level so inner unquotes are preserved.
+   * @param aCons the argument Cons whose car is the template
+   * @return the constructed form
+   */
+  quasiquote(aCons: Cons): LispValue;
+  /**
+   * Recursively expands a quasiquote template at the given nesting level.
+   * @param template the template to expand
+   * @param level the current quasiquote nesting level (1 is the outermost)
+   * @return the expanded value
+   */
+  quasiquoteExpand(template: LispValue, level: number): LispValue;
+  /**
+   * Expands the elements of a quasiquoted list, handling `unquote-splicing`
+   * (`,@`) elements and a possible dotted `unquote` (`,`) tail.
+   * @param template the list template to expand
+   * @param level the current quasiquote nesting level
+   * @return the constructed list
+   */
+  quasiquoteList(template: Cons, level: number): LispValue;
+  /**
+   * Appends the elements of a spliced value (`,@`) onto the accumulator. The
+   * value must be a proper list (or nil); an atom or an improper (dotted) list
+   * is rejected rather than silently dropping the dotted tail.
+   * @param parts the accumulator of list elements
+   * @param value the value produced by an `unquote-splicing` operand
+   */
+  spliceInto(parts: LispValue[], value: LispValue): null;
+  /**
+   * Implementation of the Lisp `unquote` (`,`) special form. Signals an error
+   * because unquote is only meaningful inside a `quasiquote` template.
+   */
+  unquote(): never;
+  /**
+   * Implementation of the Lisp `unquote-splicing` (`,@`) special form. Signals
+   * an error because unquote-splicing is only meaningful inside a `quasiquote`
+   * template.
+   */
+  unquoteSplicing(): never;
   /**
    * Implementation of the Lisp `rplaca` special form; destructively replaces the car of a Cons.
    * @param args the argument Cons containing the target Cons expression and the new car value

package/dist/index.d.ts

@@ -622,6 +622,11 @@ declare class Evaluator extends Object {
    * Lisp-name to method-name dispatch map for special forms.
    */
   static readonly buildInFunctions: Map<InterpretedSymbol, string>;
+  /**
+   * Marker symbol stored as the car of the Cons that represents a macro binding,
+   * distinguishing macros from ordinary `lambda` closures in the environment.
+   */
+  static readonly macroMarker: InterpretedSymbol;
   /**
    * The variable binding environment used during evaluation.
    */
@@ -694,6 +699,54 @@ declare class Evaluator extends Object {
    * @return the function name symbol
    */
   defun(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `defmacro` special form. Defines a macro: a
+   * transformer whose body receives its arguments unevaluated and returns a
+   * form that is then evaluated in the caller's environment.
+   * @param aCons the argument Cons containing the macro name, parameter list, and body
+   * @return the macro name symbol
+   */
+  defmacro(aCons: Cons): LispValue;
+  /**
+   * Returns the macro transformer (a lambda Cons) bound to the given symbol, or
+   * null when the symbol is not bound to a macro. Special-form symbols are never
+   * treated as macros.
+   * @param car the operator position of a call form
+   * @return the macro's lambda Cons, or null
+   */
+  lookupMacro(car: LispValue): Cons | null;
+  /**
+   * Expands a macro call exactly once by applying its transformer to the
+   * unevaluated argument forms in the macro's captured environment.
+   * @param form the call form whose car names the macro
+   * @param macroLambda the macro's transformer lambda Cons
+   * @return the expansion form
+   */
+  expandMacro1(form: Cons, macroLambda: Cons): LispValue;
+  /**
+   * Expands a macro call once and evaluates the resulting form in the current
+   * environment.
+   * @param form the call form whose car names the macro
+   * @param macroLambda the macro's transformer lambda Cons
+   * @return the result of evaluating the expansion
+   */
+  evalMacroCall(form: Cons, macroLambda: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `macroexpand-1` special form. Evaluates its
+   * argument to obtain a form and, when that form is a macro call, expands it
+   * exactly once without evaluating the result.
+   * @param aCons the argument Cons whose car evaluates to the form to expand
+   * @return the once-expanded form, or the form unchanged when it is not a macro call
+   */
+  macroexpand_1(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `macroexpand` special form. Evaluates its
+   * argument to obtain a form and repeatedly expands it until the result is no
+   * longer a macro call, without evaluating the result.
+   * @param aCons the argument Cons whose car evaluates to the form to expand
+   * @return the fully expanded form
+   */
+  macroexpand(aCons: Cons): LispValue;
   /**
    * Implementation of the Lisp `do` special form (parallel binding update).
    * @param aCons the argument Cons containing bindings, termination clause, and body
@@ -852,6 +905,49 @@ declare class Evaluator extends Object {
    * @return the quoted form
    */
   quote(aCons: Cons): LispValue;
+  /**
+   * Implementation of the Lisp `quasiquote` (`` ` ``) special form. Returns the
+   * template with every `unquote` (`,`) and `unquote-splicing` (`,@`) at the
+   * matching nesting level replaced by the evaluation of its operand. Nested
+   * quasiquotes increase the level so inner unquotes are preserved.
+   * @param aCons the argument Cons whose car is the template
+   * @return the constructed form
+   */
+  quasiquote(aCons: Cons): LispValue;
+  /**
+   * Recursively expands a quasiquote template at the given nesting level.
+   * @param template the template to expand
+   * @param level the current quasiquote nesting level (1 is the outermost)
+   * @return the expanded value
+   */
+  quasiquoteExpand(template: LispValue, level: number): LispValue;
+  /**
+   * Expands the elements of a quasiquoted list, handling `unquote-splicing`
+   * (`,@`) elements and a possible dotted `unquote` (`,`) tail.
+   * @param template the list template to expand
+   * @param level the current quasiquote nesting level
+   * @return the constructed list
+   */
+  quasiquoteList(template: Cons, level: number): LispValue;
+  /**
+   * Appends the elements of a spliced value (`,@`) onto the accumulator. The
+   * value must be a proper list (or nil); an atom or an improper (dotted) list
+   * is rejected rather than silently dropping the dotted tail.
+   * @param parts the accumulator of list elements
+   * @param value the value produced by an `unquote-splicing` operand
+   */
+  spliceInto(parts: LispValue[], value: LispValue): null;
+  /**
+   * Implementation of the Lisp `unquote` (`,`) special form. Signals an error
+   * because unquote is only meaningful inside a `quasiquote` template.
+   */
+  unquote(): never;
+  /**
+   * Implementation of the Lisp `unquote-splicing` (`,@`) special form. Signals
+   * an error because unquote-splicing is only meaningful inside a `quasiquote`
+   * template.
+   */
+  unquoteSplicing(): never;
   /**
    * Implementation of the Lisp `rplaca` special form; destructively replaces the car of a Cons.
    * @param args the argument Cons containing the target Cons expression and the new car value

package/dist/index.js

@@ -671,6 +671,31 @@ var Parser = class Parser extends Object {
 		return 0;
 	}
 	/**
+	* Recognizes a backquote (`` ` ``), wraps the following form into `(quasiquote form)`, and returns the token number; invoked from NextState.
+	* @return 0
+	*/
+	quasiquote() {
+		const anObject = new Cons(this.nextToken(), Cons.nil);
+		this.token = new Cons(InterpretedSymbol.of("quasiquote"), anObject);
+		return 0;
+	}
+	/**
+	* Recognizes a comma and wraps the following form into `(unquote form)`, or
+	* `(unquote-splicing form)` when the comma is immediately followed by `@`
+	* (i.e. `,@`); invoked from NextState.
+	* @return 0
+	*/
+	unquote() {
+		let aSymbol = InterpretedSymbol.of("unquote");
+		if (this.peekChar() === "@") {
+			this.nextChar();
+			aSymbol = InterpretedSymbol.of("unquote-splicing");
+		}
+		const anObject = new Cons(this.nextToken(), Cons.nil);
+		this.token = new Cons(aSymbol, anObject);
+		return 0;
+	}
+	/**
 	* Returns the token number for a quote or for a 0-origin String-type (pseudo-Character); invoked from NextState.
 	* @return the next state number
 	*/
@@ -790,7 +815,7 @@ var Parser = class Parser extends Object {
 		aTable.set(String(41), this.nextState(-1, null));
 		aTable.set(String(42), this.nextState(8, "symbolToken"));
 		aTable.set(String(43), this.nextState(7, "sign"));
-		aTable.set(String(44), this.nextState(8, "symbolToken"));
+		aTable.set(String(44), this.nextState(0, "unquote"));
 		aTable.set(String(45), this.nextState(7, "sign"));
 		aTable.set(String(46), this.nextState(-1, null));
 		aTable.set(String(47), this.nextState(8, "symbolToken"));
@@ -802,7 +827,7 @@ var Parser = class Parser extends Object {
 		aTable.set(String(93), this.nextState(-1, null));
 		aTable.set(String(94), this.nextState(8, "symbolToken"));
 		aTable.set(String(95), this.nextState(8, "symbolToken"));
-		aTable.set(String(96), this.nextState(0, "quote"));
+		aTable.set(String(96), this.nextState(0, "quasiquote"));
 		for (const index of IntStream.rangeClosed(97, 122)) aTable.set(String(index), this.nextState(8, "symbolToken"));
 		aTable.set(String(123), this.nextState(-1, "parseList"));
 		aTable.set(String(124), this.nextState(8, "symbolToken"));
@@ -2851,6 +2876,11 @@ var Evaluator = class Evaluator extends Object {
 	*/
 	static buildInFunctions = Evaluator.setup();
 	/**
+	* Marker symbol stored as the car of the Cons that represents a macro binding,
+	* distinguishing macros from ordinary `lambda` closures in the environment.
+	*/
+	static macroMarker = InterpretedSymbol.of("macro");
+	/**
 	* The variable binding environment used during evaluation.
 	*/
 	environment;
@@ -2996,6 +3026,85 @@ var Evaluator = class Evaluator extends Object {
 		return variable;
 	}
 	/**
+	* Implementation of the Lisp `defmacro` special form. Defines a macro: a
+	* transformer whose body receives its arguments unevaluated and returns a
+	* form that is then evaluated in the caller's environment.
+	* @param aCons the argument Cons containing the macro name, parameter list, and body
+	* @return the macro name symbol
+	*/
+	defmacro(aCons) {
+		const variable = aCons.car;
+		const lambda = Evaluator.eval(new Cons(InterpretedSymbol.of("lambda"), aCons.cdr), new Table(this.environment), this.streamManager, this.depth, this.plugins);
+		const macro = new Cons(Evaluator.macroMarker, new Cons(lambda, Cons.nil));
+		this.environment.set(variable, macro);
+		return variable;
+	}
+	/**
+	* Returns the macro transformer (a lambda Cons) bound to the given symbol, or
+	* null when the symbol is not bound to a macro. Special-form symbols are never
+	* treated as macros.
+	* @param car the operator position of a call form
+	* @return the macro's lambda Cons, or null
+	*/
+	lookupMacro(car) {
+		if (Cons.isNotSymbol(car) || Evaluator.buildInFunctions.has(car)) return null;
+		const value = this.environment.get(car);
+		if (Cons.isCons(value) && value.car === Evaluator.macroMarker) return value.nth(2);
+		return null;
+	}
+	/**
+	* Expands a macro call exactly once by applying its transformer to the
+	* unevaluated argument forms in the macro's captured environment.
+	* @param form the call form whose car names the macro
+	* @param macroLambda the macro's transformer lambda Cons
+	* @return the expansion form
+	*/
+	expandMacro1(form, macroLambda) {
+		const capturedEnvironment = macroLambda.last().car;
+		return Applier.apply(macroLambda, form.cdr, capturedEnvironment, this.streamManager, this.depth, this.plugins);
+	}
+	/**
+	* Expands a macro call once and evaluates the resulting form in the current
+	* environment.
+	* @param form the call form whose car names the macro
+	* @param macroLambda the macro's transformer lambda Cons
+	* @return the result of evaluating the expansion
+	*/
+	evalMacroCall(form, macroLambda) {
+		const expansion = this.expandMacro1(form, macroLambda);
+		return Evaluator.eval(expansion, this.environment, this.streamManager, this.depth, this.plugins);
+	}
+	/**
+	* Implementation of the Lisp `macroexpand-1` special form. Evaluates its
+	* argument to obtain a form and, when that form is a macro call, expands it
+	* exactly once without evaluating the result.
+	* @param aCons the argument Cons whose car evaluates to the form to expand
+	* @return the once-expanded form, or the form unchanged when it is not a macro call
+	*/
+	macroexpand_1(aCons) {
+		const form = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
+		if (Cons.isNotCons(form)) return form;
+		const macroLambda = this.lookupMacro(form.car);
+		if (macroLambda == null) return form;
+		return this.expandMacro1(form, macroLambda);
+	}
+	/**
+	* Implementation of the Lisp `macroexpand` special form. Evaluates its
+	* argument to obtain a form and repeatedly expands it until the result is no
+	* longer a macro call, without evaluating the result.
+	* @param aCons the argument Cons whose car evaluates to the form to expand
+	* @return the fully expanded form
+	*/
+	macroexpand(aCons) {
+		let form = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
+		while (Cons.isCons(form)) {
+			const macroLambda = this.lookupMacro(form.car);
+			if (macroLambda == null) break;
+			form = this.expandMacro1(form, macroLambda);
+		}
+		return form;
+	}
+	/**
 	* Implementation of the Lisp `do` special form (parallel binding update).
 	* @param aCons the argument Cons containing bindings, termination clause, and body
 	* @return the value of the termination clause's result form
@@ -3107,6 +3216,10 @@ var Evaluator = class Evaluator extends Object {
 		if (Cons.isNil(form) || Cons.isNotList(form)) return form;
 		const formCons = form;
 		if (Cons.isSymbol(formCons.car) && Evaluator.buildInFunctions.has(formCons.car)) return this.specialForm(formCons);
+		if (Cons.isSymbol(formCons.car)) {
+			const macroLambda = this.lookupMacro(formCons.car);
+			if (macroLambda != null) return this.evalMacroCall(formCons, macroLambda);
+		}
 		if (Cons.isSymbol(formCons.car) && this.plugins.length > 0) {
 			const symbol = formCons.car;
 			const plugin = this.plugins.find((p) => p.has(symbol));
@@ -3357,6 +3470,94 @@ var Evaluator = class Evaluator extends Object {
 		return aCons.car;
 	}
 	/**
+	* Implementation of the Lisp `quasiquote` (`` ` ``) special form. Returns the
+	* template with every `unquote` (`,`) and `unquote-splicing` (`,@`) at the
+	* matching nesting level replaced by the evaluation of its operand. Nested
+	* quasiquotes increase the level so inner unquotes are preserved.
+	* @param aCons the argument Cons whose car is the template
+	* @return the constructed form
+	*/
+	quasiquote(aCons) {
+		return this.quasiquoteExpand(aCons.car, 1);
+	}
+	/**
+	* Recursively expands a quasiquote template at the given nesting level.
+	* @param template the template to expand
+	* @param level the current quasiquote nesting level (1 is the outermost)
+	* @return the expanded value
+	*/
+	quasiquoteExpand(template, level) {
+		if (Cons.isNotCons(template)) return template;
+		const aCons = template;
+		if (aCons.car === InterpretedSymbol.of("unquote")) {
+			if (level === 1) return Evaluator.eval(aCons.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
+			return new Cons(InterpretedSymbol.of("unquote"), new Cons(this.quasiquoteExpand(aCons.nth(2), level - 1), Cons.nil));
+		}
+		if (aCons.car === InterpretedSymbol.of("quasiquote")) return new Cons(InterpretedSymbol.of("quasiquote"), new Cons(this.quasiquoteExpand(aCons.nth(2), level + 1), Cons.nil));
+		return this.quasiquoteList(aCons, level);
+	}
+	/**
+	* Expands the elements of a quasiquoted list, handling `unquote-splicing`
+	* (`,@`) elements and a possible dotted `unquote` (`,`) tail.
+	* @param template the list template to expand
+	* @param level the current quasiquote nesting level
+	* @return the constructed list
+	*/
+	quasiquoteList(template, level) {
+		const parts = [];
+		let tail = Cons.nil;
+		let current = template;
+		while (Cons.isCons(current)) {
+			if (current.car === InterpretedSymbol.of("unquote")) {
+				tail = this.quasiquoteExpand(current, level);
+				current = Cons.nil;
+				break;
+			}
+			const head = current.car;
+			if (Cons.isCons(head) && head.car === InterpretedSymbol.of("unquote-splicing")) if (level === 1) this.spliceInto(parts, Evaluator.eval(head.nth(2), this.environment, this.streamManager, this.depth, this.plugins));
+			else parts.push(new Cons(InterpretedSymbol.of("unquote-splicing"), new Cons(this.quasiquoteExpand(head.nth(2), level - 1), Cons.nil)));
+			else parts.push(this.quasiquoteExpand(head, level));
+			current = current.cdr;
+		}
+		if (Cons.isNotNil(current)) tail = current;
+		let result = tail;
+		for (let index = parts.length - 1; index >= 0; index--) result = new Cons(parts[index], result);
+		return result;
+	}
+	/**
+	* Appends the elements of a spliced value (`,@`) onto the accumulator. The
+	* value must be a proper list (or nil); an atom or an improper (dotted) list
+	* is rejected rather than silently dropping the dotted tail.
+	* @param parts the accumulator of list elements
+	* @param value the value produced by an `unquote-splicing` operand
+	*/
+	spliceInto(parts, value) {
+		if (Cons.isNil(value)) return null;
+		if (Cons.isNotCons(value)) throw new EvalError(cannotApply("unquote-splicing", value));
+		let current = value;
+		while (Cons.isCons(current)) {
+			parts.push(current.car);
+			current = current.cdr;
+		}
+		if (Cons.isNotNil(current)) throw new EvalError(cannotApply("unquote-splicing", value));
+		return null;
+	}
+	/**
+	* Implementation of the Lisp `unquote` (`,`) special form. Signals an error
+	* because unquote is only meaningful inside a `quasiquote` template.
+	*/
+	unquote() {
+		throw new EvalError("unquote (\",\") is only valid inside a quasiquote (\"`\")");
+	}
+	/**
+	* Implementation of the Lisp `unquote-splicing` (`,@`) special form. Signals
+	* an error because unquote-splicing is only meaningful inside a `quasiquote`
+	* template.
+	*/
+	unquoteSplicing() {
+		throw new EvalError("unquote-splicing (\",@\") is only valid inside a quasiquote (\"`\")");
+	}
+	/**
 	* Implementation of the Lisp `rplaca` special form; destructively replaces the car of a Cons.
 	* @param args the argument Cons containing the target Cons expression and the new car value
 	* @return the modified Cons
@@ -3434,6 +3635,7 @@ var Evaluator = class Evaluator extends Object {
 				["apply", "apply_lisp"],
 				["bind", "bind"],
 				["cond", "cond"],
+				["defmacro", "defmacro"],
 				["defun", "defun"],
 				["do", "do_"],
 				["dolist", "doList"],
@@ -3445,6 +3647,8 @@ var Evaluator = class Evaluator extends Object {
 				["lambda", "lambda"],
 				["let", "let"],
 				["let*", "letStar"],
+				["macroexpand", "macroexpand"],
+				["macroexpand-1", "macroexpand_1"],
 				["not", "not"],
 				["notrace", "notrace"],
 				["or", "or"],
@@ -3453,6 +3657,7 @@ var Evaluator = class Evaluator extends Object {
 				["princ", "princ"],
 				["print", "print"],
 				["push", "push_"],
+				["quasiquote", "quasiquote"],
 				["quote", "quote"],
 				["rplaca", "rplaca"],
 				["rplacd", "rplacd"],
@@ -3462,6 +3667,8 @@ var Evaluator = class Evaluator extends Object {
 				["time", "time"],
 				["trace", "trace"],
 				["unless", "unless"],
+				["unquote", "unquote"],
+				["unquote-splicing", "unquoteSplicing"],
 				["when", "when"]
 			].map(([key, value]) => [InterpretedSymbol.of(key), value]));
 		} catch {
@@ -3656,7 +3863,7 @@ var LispInterpreter = class extends Object {
 		const aList = [];
 		const aTable = new Table();
 		aTable.setRoot(true);
-		aList.push("abs", "add", "and", "apply", "assoc", "atom", "bind", "car", "cdr", "characterp", "cond", "ceiling", "concatenate", "cons", "consp", "copy", "cos", "count", "floatp", "floor", "defun", "divide", "do", "do*", "dolist", "doublep", "elt", "eq", "equal", "eval", "evenp", "every", "exit", "exp", "expt", "find", "format", "gc", "gensym", "if", "integerp", "lambda", "let", "let*", "last", "length", "list", "listp", "mapcan", "mapcar", "max", "member", "memq", "min", "minusp", "mod", "multiply", "napier", "neq", "nequal", "not", "notrace", "nth", "null", "numberp", "oddp", "or", "pi", "plusp", "pop", "princ", "print", "progn", "push", "quote", "random", "reduce", "round", "rplaca", "rplacd", "setq", "set-allq", "sin", "some", "sort", "sqrt", "string-downcase", "string-trim", "string-upcase", "stringp", "subseq", "substring", "subtract", "symbolp", "tan", "terpri", "time", "trace", "truncate", "unless", "when", "zerop", "1+", "1-", "+", "-", "*", "/", "//", "=", "==", "~=", "~~", "<", "<=", ">", ">=");
+		aList.push("abs", "add", "and", "apply", "assoc", "atom", "bind", "car", "cdr", "characterp", "cond", "ceiling", "concatenate", "cons", "consp", "copy", "cos", "count", "floatp", "floor", "defmacro", "defun", "divide", "do", "do*", "dolist", "doublep", "elt", "eq", "equal", "eval", "evenp", "every", "exit", "exp", "expt", "find", "format", "gc", "gensym", "if", "integerp", "lambda", "let", "let*", "last", "length", "list", "listp", "macroexpand", "macroexpand-1", "mapcan", "mapcar", "max", "member", "memq", "min", "minusp", "mod", "multiply", "napier", "neq", "nequal", "not", "notrace", "nth", "null", "numberp", "oddp", "or", "pi", "plusp", "pop", "princ", "print", "progn", "push", "quasiquote", "quote", "random", "reduce", "round", "rplaca", "rplacd", "setq", "set-allq", "sin", "some", "sort", "sqrt", "string-downcase", "string-trim", "string-upcase", "stringp", "subseq", "substring", "subtract", "symbolp", "tan", "terpri", "time", "trace", "truncate", "unless", "unquote", "unquote-splicing", "when", "zerop", "1+", "1-", "+", "-", "*", "/", "//", "=", "==", "~=", "~~", "<", "<=", ">", ">=");
 		for (const each of aList) {
 			const aSymbol = InterpretedSymbol.of(each);
 			aTable.set(aSymbol, aSymbol);