An interpreter for concatenative languages with JSON syntax.
This interpreter implements a simple, generic class of homoiconic concatenative language designed for ease of interpretation and ease of synthesis; it is not intended primarily to be written or read by humans, although it certainly can be. The specific language to interpret is determined by an input op table.
The module exports a single
interpret function with the signature
interpret(opTable: OpTable, ast: any, stack: any, ctx?: Object): Promise<any>.
opTableis an object whose keys map to
Operatorfunctions, with the signature
(interp: (code: any, ...args: any) => Promise<any>, ctx: Object, ...args: any) => Promise<any>. The first argument to an operator function is recursive callback into the interpreter, which allows for executing nested code blocks; this facility would be used by the implementation of, e.g., conditionals or loops.
astis an array of containing the code/data to be executed.
stackis an array to use as the starting state of the program data stack.
ctxis an arbitrary object which will be passed in to all operations which can be used to hold arbitrary mutable context data. If no explicit context is provided, an empty object is created for internal use.
The contents of the
ast array are interpreted as follows:
- Strings beginning with "#" are treated as calls to built-in functions to be looked up in the op table.
- Embedded arrays are contextually treated either as anonymous function definitions or data lists, either of which will be pushed onto the data stack. (If a subsequent function call passes the array to
interpfor evaluation, then it is code; otherwise, it is data.)
- All other JSON values are treated as functions that simply place their own value onto the data stack. E.g.,
1just pushes the numeric value 1 onto the data stack,
"hello"pushes the string "hello" onto the data stack, etc.