fez-lisp 1.2.15 → 1.2.17

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.2.15",
+  "version": "1.2.17",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/interpreter.js

@@ -799,140 +799,4 @@ const keywords = {
 }
 keywords[KEYWORDS.NOT_COMPILED_BLOCK] = keywords[KEYWORDS.BLOCK]
 
-export const deSuggar = (ast) => {
-  if (ast.length === 0)
-    throw new SyntaxError(
-      `Top level ${KEYWORDS.NUMBER_TYPE} need to be wrapped in a (${KEYWORDS.IDENTITY})`
-    )
-  // for (const node of ast)
-  //   if (node[0] && node[0][TYPE] === APPLY && node[0][VALUE] === KEYWORDS.BLOCK)
-  //     throw new SyntaxError(`Top level (${KEYWORDS.BLOCK}) is not allowed`)
-  let prev = undefined
-  const evaluate = (exp) => {
-    const [first, ...rest] = isLeaf(exp) ? [exp] : exp
-    if (first != undefined) {
-      switch (first[TYPE]) {
-        case WORD:
-          break
-        case ATOM:
-          break
-        case APPLY:
-          {
-            switch (first[VALUE]) {
-              case KEYWORDS.BLOCK:
-                {
-                  if (
-                    prev == undefined ||
-                    (prev &&
-                      prev[TYPE] === APPLY &&
-                      prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
-                  ) {
-                    exp[0][1] = KEYWORDS.CALL_FUNCTION
-                    exp[0][0] = APPLY
-                    exp.length = 1
-                    exp[1] = [
-                      [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
-                      [[APPLY, KEYWORDS.BLOCK], ...rest]
-                    ]
-                    deSuggar(exp)
-                  }
-                }
-                break
-              // case KEYWORDS.DEFINE_VARIABLE:
-              //   {
-              //     if (
-              //       rest[1] &&
-              //       rest[1][0] &&
-              //       rest[1][0][TYPE] === APPLY &&
-              //       rest[1][0][VALUE] === KEYWORDS.BLOCK
-              //     ) {
-              //       throw new SyntaxError(
-              //         `Can't use (${KEYWORDS.BLOCK}) in (${KEYWORDS.DEFINE_VARIABLE})`
-              //       )
-              //     }
-              //   }
-              // break
-              case KEYWORDS.PIPE:
-                {
-                  if (rest.length < 1)
-                    throw new RangeError(
-                      `Invalid number of arguments to (${
-                        KEYWORDS.PIPE
-                      }) (>= 1 required). (${KEYWORDS.PIPE} ${stringifyArgs(
-                        rest
-                      )})`
-                    )
-                  let inp = rest[0]
-                  exp.length = 0
-                  for (let i = 1; i < rest.length; ++i) {
-                    if (!rest[i].length || rest[i][0][TYPE] !== APPLY)
-                      throw new TypeError(
-                        `Argument at position (${i}) of (${
-                          KEYWORDS.PIPE
-                        }) is not an invoked (${
-                          KEYWORDS.ANONYMOUS_FUNCTION
-                        }). (${KEYWORDS.PIPE} ${stringifyArgs(rest)})`
-                      )
-                    inp = [rest[i].shift(), inp, ...rest[i]]
-                  }
-                  for (let i = 0; i < inp.length; ++i) exp[i] = inp[i]
-                  deSuggar(exp)
-                }
-                break
-              case KEYWORDS.LIST_TYPE:
-                {
-                  exp.length = 0
-                  let temp = exp
-                  for (const item of rest) {
-                    temp.push([0, KEYWORDS.ARRAY_TYPE], item, [])
-                    temp = temp.at(-1)
-                  }
-                  temp.push([0, 'array'])
-                  deSuggar(exp)
-                }
-                break
-              case KEYWORDS.MULTIPLICATION:
-                if (!rest.length) {
-                  exp[0][0] = 2
-                  exp[0][1] = 1
-                }
-                break
-              case KEYWORDS.ADDITION:
-              case KEYWORDS.DIVISION:
-                if (!rest.length) {
-                  exp[0][0] = 2
-                  exp[0][1] = 0
-                }
-                break
-              case KEYWORDS.UNLESS:
-                {
-                  if (rest.length > 3 || rest.length < 2)
-                    throw new RangeError(
-                      `Invalid number of arguments for (${
-                        KEYWORDS.UNLESS
-                      }), expected (or (= 3) (= 2)) but got ${rest.length} (${
-                        KEYWORDS.UNLESS
-                      } ${stringifyArgs(rest)})`
-                    )
-                  exp[0][1] = KEYWORDS.IF
-                  const temp = exp[2]
-                  exp[2] = exp[3] ?? [ATOM, 0]
-                  exp[3] = temp
-                }
-                break
-            }
-            prev = first
-          }
-          break
-        default:
-          for (const e of exp) evaluate(e)
-          break
-      }
-      for (const r of rest) evaluate(r)
-    }
-  }
-  evaluate(ast)
-  return ast
-}
-
 export { keywords }

package/src/keywords.js

@@ -7,9 +7,7 @@ export const TRUE = 1
 export const FALSE = 0
 export const PLACEHOLDER = '.'
 export const KEYWORDS = {
-  RECURSION: 'rec',
   NUMBER_TYPE: 'number',
-  LIST_TYPE: 'list',
   ARRAY_TYPE: 'array',
   IDENTITY: 'identity',
   ARRAY_LENGTH: 'length',
@@ -31,7 +29,6 @@ export const KEYWORDS = {
   BLOCK: 'do',
   ANONYMOUS_FUNCTION: 'lambda',
   IF: 'if',
-  UNLESS: 'unless',
   CONDITION: 'cond',
   NOT: 'not',
   EQUAL: '=',
@@ -41,9 +38,9 @@ export const KEYWORDS = {
   LESS_THAN_OR_EQUAL: '<=',
   AND: 'and',
   OR: 'or',
+
   CALL_FUNCTION: 'apply',
   DEFINE_VARIABLE: 'let',
-  PIPE: '|>',
 
   SET_ARRAY: 'set!',
 
@@ -51,7 +48,15 @@ export const KEYWORDS = {
   LOG: 'log!',
   LOG_STRING: 'log-string!',
   LOG_CHAR: 'log-char!',
-  CLEAR_CONSOLE: 'clear!'
+  CLEAR_CONSOLE: 'clear!',
+
+  // Syntactic suggars
+  PIPE: '|>',
+  NOT_EQUAL_1: '!=',
+  NOT_EQUAL_2: '<>',
+  UNLESS: 'unless',
+  LIST_TYPE: 'list',
+  RECURSION: 'rec'
 }
 
 export const TYPES = {

package/src/utils.js

@@ -1,9 +1,8 @@
 import std from '../lib/baked/std.js'
 import { comp } from './compiler.js'
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
-import { run } from './evaluator.js'
+import { evaluate, run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
-import { deSuggar } from './interpreter.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
@@ -228,6 +227,8 @@ export const dfs = (tree, callback) => {
   else callback(tree)
 }
 export const deepClone = (ast) => AST.parse(AST.stringify(ast))
+export const interpret = (ast, keywords) =>
+  ast.reduce((_, x) => evaluate(x, keywords), 0)
 export const fez = (source, options = {}) => {
   const env = Object.create(null)
   try {
@@ -355,3 +356,155 @@ export const js = (source, deps) => {
   ])
   return `${top}${program}`
 }
+
+export const deSuggar = (ast) => {
+  if (ast.length === 0) throw new SyntaxError(`No expressions to evaluate`)
+  // for (const node of ast)
+  //   if (node[0] && node[0][TYPE] === APPLY && node[0][VALUE] === KEYWORDS.BLOCK)
+  //     throw new SyntaxError(`Top level (${KEYWORDS.BLOCK}) is not allowed`)
+  let prev = undefined
+  const evaluate = (exp) => {
+    const [first, ...rest] = isLeaf(exp) ? [exp] : exp
+    if (first != undefined) {
+      switch (first[TYPE]) {
+        case WORD:
+          break
+        case ATOM:
+          break
+        case APPLY:
+          {
+            switch (first[VALUE]) {
+              case KEYWORDS.BLOCK:
+                {
+                  if (
+                    prev == undefined ||
+                    (prev &&
+                      prev[TYPE] === APPLY &&
+                      prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
+                  ) {
+                    exp[0][1] = KEYWORDS.CALL_FUNCTION
+                    exp[0][0] = APPLY
+                    exp.length = 1
+                    exp[1] = [
+                      [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
+                      [[APPLY, KEYWORDS.BLOCK], ...rest]
+                    ]
+                    deSuggar(exp)
+                  }
+                }
+                break
+              // case KEYWORDS.DEFINE_VARIABLE:
+              //   {
+              //     if (
+              //       rest[1] &&
+              //       rest[1][0] &&
+              //       rest[1][0][TYPE] === APPLY &&
+              //       rest[1][0][VALUE] === KEYWORDS.BLOCK
+              //     ) {
+              //       throw new SyntaxError(
+              //         `Can't use (${KEYWORDS.BLOCK}) in (${KEYWORDS.DEFINE_VARIABLE})`
+              //       )
+              //     }
+              //   }
+              // break
+              case KEYWORDS.PIPE:
+                {
+                  if (rest.length < 1)
+                    throw new RangeError(
+                      `Invalid number of arguments to (${
+                        KEYWORDS.PIPE
+                      }) (>= 1 required). (${KEYWORDS.PIPE} ${stringifyArgs(
+                        rest
+                      )})`
+                    )
+                  let inp = rest[0]
+                  exp.length = 0
+                  for (let i = 1; i < rest.length; ++i) {
+                    if (!rest[i].length || rest[i][0][TYPE] !== APPLY)
+                      throw new TypeError(
+                        `Argument at position (${i}) of (${
+                          KEYWORDS.PIPE
+                        }) is not an invoked (${
+                          KEYWORDS.ANONYMOUS_FUNCTION
+                        }). (${KEYWORDS.PIPE} ${stringifyArgs(rest)})`
+                      )
+                    inp = [rest[i].shift(), inp, ...rest[i]]
+                  }
+                  for (let i = 0; i < inp.length; ++i) exp[i] = inp[i]
+                  deSuggar(exp)
+                }
+                break
+              case KEYWORDS.LIST_TYPE:
+                {
+                  exp.length = 0
+                  let temp = exp
+                  for (const item of rest) {
+                    temp.push([0, KEYWORDS.ARRAY_TYPE], item, [])
+                    temp = temp.at(-1)
+                  }
+                  temp.push([0, 'array'])
+                  deSuggar(exp)
+                }
+                break
+              case KEYWORDS.MULTIPLICATION:
+                if (!rest.length) {
+                  exp[0][0] = 2
+                  exp[0][1] = 1
+                }
+                break
+              case KEYWORDS.ADDITION:
+              case KEYWORDS.DIVISION:
+                if (!rest.length) {
+                  exp[0][0] = 2
+                  exp[0][1] = 0
+                }
+                break
+              case KEYWORDS.UNLESS:
+                {
+                  if (rest.length > 3 || rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        KEYWORDS.UNLESS
+                      }), expected (or (= 3) (= 2)) but got ${rest.length} (${
+                        KEYWORDS.UNLESS
+                      } ${stringifyArgs(rest)})`
+                    )
+                  exp[0][1] = KEYWORDS.IF
+                  const temp = exp[2]
+                  exp[2] = exp[3] ?? [ATOM, 0]
+                  exp[3] = temp
+                }
+                deSuggar(exp)
+                break
+
+              case KEYWORDS.NOT_EQUAL_1:
+              case KEYWORDS.NOT_EQUAL_2:
+                {
+                  if (rest.length > 3 || rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        exp[0][1]
+                      }), expected (or (= 3) (= 2)) but got ${rest.length} (${
+                        exp[0][1]
+                      } ${stringifyArgs(rest)})`
+                    )
+                  exp[0][1] = KEYWORDS.NOT
+                  exp[1] = [[APPLY, KEYWORDS.EQUAL], exp[1], exp[2]]
+                  exp.length = 2
+                  deSuggar(exp)
+                }
+                break
+            }
+            prev = first
+          }
+          break
+        default:
+          for (const e of exp) evaluate(e)
+          break
+      }
+      for (const r of rest) evaluate(r)
+    }
+  }
+  evaluate(ast)
+  return ast
+}