fez-lisp 1.3.2 → 1.3.4

package/package.json

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

package/src/compiler.js

@@ -7,8 +7,11 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { SUGGAR } from './macros.js'
 import { leaf, isLeaf, AST } from './parser.js'
+export const OPTIMIZATIONS = {
+  RECURSION: 'recursive',
+  CACHE: 'memoized'
+}
 const deepRename = (name, newName, tree) => {
   if (!isLeaf(tree))
     for (const leaf of tree) {
@@ -176,9 +179,9 @@ const compile = (tree, Drill) => {
       case KEYWORDS.DEFINE_VARIABLE: {
         const n = Arguments[0][VALUE]
         const prefix = n.split(':')[0]
-        if (prefix === SUGGAR.RECURSION) {
+        if (prefix === OPTIMIZATIONS.RECURSION) {
           const name = lispToJavaScriptVariableName(n)
-          const newName = `${SUGGAR.RECURSION}_${performance
+          const newName = `${OPTIMIZATIONS.RECURSION}_${performance
             .now()
             .toString()
             .replace('.', 7)}`
@@ -199,10 +202,10 @@ const compile = (tree, Drill) => {
           )})=>{${vars}return ${evaluatedBody
             .toString()
             .trim()}}, ${newName})));`
-        } else if (prefix === SUGGAR.CACHE) {
+        } else if (prefix === OPTIMIZATIONS.CACHE) {
           // memoization here
           const name = lispToJavaScriptVariableName(n)
-          const newName = name.substring(SUGGAR.CACHE.length + 1)
+          const newName = name.substring(OPTIMIZATIONS.CACHE.length + 1)
           Drill.Variables.add(name)
           const functionArgs = Arguments.at(-1).slice(1)
           const body = functionArgs.pop()
@@ -230,7 +233,7 @@ const compile = (tree, Drill) => {
       case KEYWORDS.IS_LAMBDA:
         Drill.Helpers.add('lambda_predicate')
         return `lambda_predicate(${compile(Arguments[0], Drill)});`
-      case KEYWORDS.ARRAY_TYPE:
+      case KEYWORDS.CREATE_ARRAY:
         return `[${parseArgs(Arguments, Drill)}];`
       case KEYWORDS.ARRAY_LENGTH:
         Drill.Helpers.add('length')

package/src/interpreter.js

@@ -1,40 +1,87 @@
-import { TYPE, VALUE, WORD, KEYWORDS, FALSE, TRUE, TYPES } from './keywords.js'
+import {
+  TYPE,
+  VALUE,
+  WORD,
+  KEYWORDS,
+  FALSE,
+  TRUE,
+  TYPES,
+  RUNTIME_TYPES
+} from './keywords.js'
 import { evaluate } from './evaluator.js'
 import { isForbiddenVariableName, stringifyArgs } from './utils.js'
 export const keywords = {
-  [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
-    if (args.length !== 2)
+  [KEYWORDS.ADDITION]: (args, env) => {
+    if (args.length !== 0 && args.length !== 2)
       throw new RangeError(
         `Invalid number of arguments for (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        }), expected (= 2) but got ${args.length}. (${
-          KEYWORDS.REMAINDER_OF_DIVISION
+          KEYWORDS.ADDITION
+        }), expected (or (= 2) (= 0)) but got ${args.length}. (${
+          KEYWORDS.ADDITION
         } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
       throw new TypeError(
-        `First argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
+        `First arguments of (${KEYWORDS.ADDITION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
       )
     const b = evaluate(args[1], env)
     if (typeof b !== 'number')
       throw new TypeError(
-        `Second argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
+        `Second arguments of (${KEYWORDS.ADDITION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
       )
-    if (b === 0)
+    return a + b
+  },
+  [KEYWORDS.MULTIPLICATION]: (args, env) => {
+    if (args.length !== 2)
+      throw new RangeError(
+        `Invalid number of arguments for (${KEYWORDS.MULTIPLICATION}), expected (= 2) but got ${args.length}.`
+      )
+    const a = evaluate(args[0], env)
+    if (typeof a !== 'number')
       throw new TypeError(
-        `Second argument of (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        }) can't be a (0) (division by 0 is not allowed) (${
-          KEYWORDS.REMAINDER_OF_DIVISION
+        `First arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
+      )
+    const b = evaluate(args[1], env)
+    if (typeof b !== 'number')
+      throw new TypeError(
+        `Second arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
+      )
+    return a * b
+  },
+  [KEYWORDS.SUBTRACTION]: (args, env) => {
+    if (args.length !== 1 && args.length !== 2)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.SUBTRACTION
+        }), expected (or (= 1)) (= 2) but got ${args.length}. (${
+          KEYWORDS.SUBTRACTION
         } ${stringifyArgs(args)})`
       )
-
-    return a % b
+    const a = evaluate(args[0], env)
+    if (typeof a !== 'number')
+      throw new TypeError(
+        `First argument of (${KEYWORDS.SUBTRACTION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+      )
+    if (args.length === 1) return -a
+    const b = evaluate(args[1], env)
+    if (typeof b !== 'number')
+      throw new TypeError(
+        `Second argument of (${KEYWORDS.SUBTRACTION}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+      )
+    return a - b
   },
   [KEYWORDS.DIVISION]: (args, env) => {
     if (args.length !== 2)
@@ -45,14 +92,14 @@ export const keywords = {
     if (typeof a !== 'number')
       throw new TypeError(
         `First argument of (${KEYWORDS.DIVISION}) is not (${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
       )
     const b = evaluate(args[1], env)
     if (typeof b !== 'number')
       throw new TypeError(
         `Second argument of (${KEYWORDS.DIVISION}) is not (${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
       )
     if (b === 0)
@@ -65,135 +112,164 @@ export const keywords = {
       )
     return a / b
   },
-  [KEYWORDS.ARRAY_LENGTH]: (args, env) => {
-    if (args.length !== 1)
+  [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
+    if (args.length !== 2)
       throw new RangeError(
         `Invalid number of arguments for (${
-          KEYWORDS.ARRAY_LENGTH
-        }) (= 1 required) (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
+          KEYWORDS.REMAINDER_OF_DIVISION
+        }), expected (= 2) but got ${args.length}. (${
+          KEYWORDS.REMAINDER_OF_DIVISION
+        } ${stringifyArgs(args)})`
       )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
+    const a = evaluate(args[0], env)
+    if (typeof a !== 'number')
       throw new TypeError(
-        `First argument of (${KEYWORDS.ARRAY_LENGTH}) must be an ${
-          KEYWORDS.ARRAY_TYPE
-        } (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
+        `First argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
       )
-    return array.length
+    const b = evaluate(args[1], env)
+    if (typeof b !== 'number')
+      throw new TypeError(
+        `Second argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
+      )
+    if (b === 0)
+      throw new TypeError(
+        `Second argument of (${
+          KEYWORDS.REMAINDER_OF_DIVISION
+        }) can't be a (0) (division by 0 is not allowed) (${
+          KEYWORDS.REMAINDER_OF_DIVISION
+        } ${stringifyArgs(args)})`
+      )
+
+    return a % b
   },
-  [KEYWORDS.IS_ATOM]: (args, env) => {
-    if (args.length !== 1)
+  [KEYWORDS.BITWISE_AND]: (args, env) => {
+    if (args.length < 2)
       throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_ATOM
-        }) (= 1 required) (${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_AND
+        }) (= 2 required). (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
       )
-    return +(typeof evaluate(args[0], env) === 'number')
+    const operands = args.map((a) => evaluate(a, env))
+    if (operands.some((x) => typeof x !== 'number'))
+      throw new TypeError(
+        `Not all arguments of (${KEYWORDS.BITWISE_AND}) are ${
+          RUNTIME_TYPES.NUMBER
+        } (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
+      )
+    return operands.reduce((acc, x) => acc & x)
   },
-  [KEYWORDS.IS_LAMBDA]: (args, env) => {
+  [KEYWORDS.BITWISE_NOT]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_LAMBDA
-        }) (= 1 required) (${KEYWORDS.IS_LAMBDA} ${stringifyArgs(args)})`
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_NOT
+        }) (= 1 required). (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
       )
-    return +(typeof evaluate(args[0], env) === 'function')
+    const operand = evaluate(args[0], env)
+    if (typeof operand !== 'number')
+      throw new TypeError(
+        `Argument of (${KEYWORDS.BITWISE_NOT}) is not a (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
+      )
+    return ~operand
   },
-  [KEYWORDS.ADDITION]: (args, env) => {
-    if (args.length !== 0 && args.length !== 2)
+  [KEYWORDS.BITWISE_OR]: (args, env) => {
+    if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.ADDITION
-        }), expected (or (= 2) (= 0)) but got ${args.length}. (${
-          KEYWORDS.ADDITION
-        } ${stringifyArgs(args)})`
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_OR
+        }) (= 2 required). (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `First arguments of (${KEYWORDS.ADDITION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
-      )
     const b = evaluate(args[1], env)
-    if (typeof b !== 'number')
+    if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
-        `Second arguments of (${KEYWORDS.ADDITION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
+        `Not all arguments of (${KEYWORDS.BITWISE_OR}) are (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
       )
-    return a + b
+    return a | b
   },
-  [KEYWORDS.MULTIPLICATION]: (args, env) => {
+  [KEYWORDS.BITWISE_XOR]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.MULTIPLICATION}), expected (= 2) but got ${args.length}.`
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_XOR
+        }) (= 2 required). (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `First arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
-      )
     const b = evaluate(args[1], env)
-    if (typeof b !== 'number')
+    if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
-        `Second arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
+        `Not all arguments of (${KEYWORDS.BITWISE_XOR}) are (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
       )
-    return a * b
+    return a ^ b
   },
-  [KEYWORDS.SUBTRACTION]: (args, env) => {
-    if (args.length !== 1 && args.length !== 2)
+  [KEYWORDS.BITWISE_LEFT_SHIFT]: (args, env) => {
+    if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.SUBTRACTION
-        }), expected (or (= 1)) (= 2) but got ${args.length}. (${
-          KEYWORDS.SUBTRACTION
-        } ${stringifyArgs(args)})`
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_LEFT_SHIFT
+        }) (= 2 required). (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
-    if (typeof a !== 'number')
+    const b = evaluate(args[1], env)
+    if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
-        `First argument of (${KEYWORDS.SUBTRACTION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+        `Not all arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) are (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
       )
-    if (args.length === 1) return -a
+    return a << b
+  },
+  [KEYWORDS.BITWISE_RIGHT_SHIFT]: (args, env) => {
+    if (args.length !== 2)
+      throw new RangeError(
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_RIGHT_SHIFT
+        }) (= 2 required). (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
+          args
+        )})`
+      )
+    const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
-    if (typeof b !== 'number')
+    if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
-        `Second argument of (${KEYWORDS.SUBTRACTION}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+        `Not all arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) are (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
       )
-    return a - b
+    return a >> b
   },
-  [KEYWORDS.IF]: (args, env) => {
-    if (args.length > 3 || args.length < 2)
+  [KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT]: (args, env) => {
+    if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IF
-        }), expected (or (= 3) (= 2)) but got ${args.length} (${
-          KEYWORDS.IF
+        `Invalid number of arguments to (${
+          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
+        }) (= 2 required). (${
+          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
         } ${stringifyArgs(args)})`
       )
-    const condition = evaluate(args[0], env)
-    if (condition !== FALSE && condition !== TRUE)
+    const a = evaluate(args[0], env)
+    const b = evaluate(args[1], env)
+    if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
-        `Condition of (${KEYWORDS.IF}) must be ${TRUE} or ${FALSE} but got (${
-          KEYWORDS.IF
-        } ${stringifyArgs(args)})`
+        `Not all arguments of (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT}) are (${
+          RUNTIME_TYPES.NUMBER
+        }) (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(args)})`
       )
-    return condition
-      ? evaluate(args[1], env)
-      : args.length === 3
-      ? evaluate(args[2], env)
-      : 0
+    return a >>> b
   },
-  [KEYWORDS.ARRAY_TYPE]: (args, env) => {
+  [KEYWORDS.CREATE_ARRAY]: (args, env) => {
     return args.length ? args.map((x) => evaluate(x, env)) : []
   },
   [KEYWORDS.GET_ARRAY]: (args, env) => {
@@ -207,71 +283,117 @@ export const keywords = {
     if (!Array.isArray(array))
       throw new TypeError(
         `First argument of (${KEYWORDS.GET_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
+          RUNTIME_TYPES.ARRAY
         })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     if (array.length === 0)
       throw new RangeError(
         `First argument of (${KEYWORDS.GET_ARRAY}) is an empty (${
-          KEYWORDS.ARRAY_TYPE
+          RUNTIME_TYPES.ARRAY
         })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)}))`
       )
     const index = evaluate(args[1], env)
     if (!Number.isInteger(index))
       throw new TypeError(
         `Second argument of (${KEYWORDS.GET_ARRAY}) must be an (32 bit ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         }) (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     if (index > array.length - 1 || index * -1 > array.length)
       throw new RangeError(
         `Second argument of (${KEYWORDS.GET_ARRAY}) is outside of (${
-          KEYWORDS.ARRAY_TYPE
+          RUNTIME_TYPES.ARRAY
         }) bounds (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     const value = array.at(index)
     if (value == undefined)
       throw new RangeError(
-        `Trying to get a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
+        `Trying to get a null value in (${RUNTIME_TYPES.ARRAY}) at (${
           KEYWORDS.GET_ARRAY
         }) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     return value
   },
-  [KEYWORDS.BLOCK]: (args, env) => {
-    if (!args.length)
+  [KEYWORDS.SET_ARRAY]: (args, env) => {
+    if (args.length !== 1 && args.length !== 3)
       throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.BLOCK}) (>= 1 required) (${
-          KEYWORDS.BLOCK
-        } ${stringifyArgs(args)})`
+        `Invalid number of arguments for (${
+          KEYWORDS.SET_ARRAY
+        }) (or 1 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
       )
-    return args.reduce((_, x) => evaluate(x, env), 0)
-  },
-  [KEYWORDS.ANONYMOUS_FUNCTION]: (args, env) => {
-    const params = args.slice(0, -1)
-    const body = args.at(-1)
-    return (props = [], scope) => {
-      if (props.length !== params.length)
+    const array = evaluate(args[0], env)
+    if (!Array.isArray(array))
+      throw new TypeError(
+        `First argument of (${KEYWORDS.SET_ARRAY}) must be an (${
+          RUNTIME_TYPES.ARRAY
+        }) but got (${array}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+      )
+    if (args.length === 1) {
+      array.pop()
+    } else {
+      const index = evaluate(args[1], env)
+      if (!Number.isInteger(index) || index < 0)
+        throw new TypeError(
+          `Second argument of (${KEYWORDS.SET_ARRAY}) must be a positive (${
+            RUNTIME_TYPES.NUMBER
+          } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        )
+      if (index > array.length)
         throw new RangeError(
-          `Incorrect number of arguments for (${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          } ${stringifyArgs(params)}) are provided. (expects ${
-            params.length
-          } but got ${props.length}) (${
-            KEYWORDS.ANONYMOUS_FUNCTION
+          `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
+            RUNTIME_TYPES.ARRAY
+          }) bounds (index ${index} bounds ${array.length}) (${
+            KEYWORDS.SET_ARRAY
           } ${stringifyArgs(args)})`
         )
-      const localEnv = Object.create(env)
-      // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
-      for (let i = 0; i < props.length; ++i) {
-        const value = evaluate(props[i], scope)
-        Object.defineProperty(localEnv, params[i][VALUE], {
-          value,
-          writable: true
-        })
-      }
-      return evaluate(body, localEnv)
+      const value = evaluate(args[2], env)
+      if (value == undefined)
+        throw new RangeError(
+          `Trying to set a null value in (${RUNTIME_TYPES.ARRAY}) at (${
+            KEYWORDS.SET_ARRAY
+          }). (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        )
+      array[index] = value
     }
+    return array
+  },
+  [KEYWORDS.ARRAY_LENGTH]: (args, env) => {
+    if (args.length !== 1)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.ARRAY_LENGTH
+        }) (= 1 required) (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
+      )
+    const array = evaluate(args[0], env)
+    if (!Array.isArray(array))
+      throw new TypeError(
+        `First argument of (${KEYWORDS.ARRAY_LENGTH}) must be an ${
+          RUNTIME_TYPES.ARRAY
+        } (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
+      )
+    return array.length
+  },
+  [KEYWORDS.IF]: (args, env) => {
+    if (args.length > 3 || args.length < 2)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.IF
+        }), expected (or (= 3) (= 2)) but got ${args.length} (${
+          KEYWORDS.IF
+        } ${stringifyArgs(args)})`
+      )
+    const condition = evaluate(args[0], env)
+    if (condition !== FALSE && condition !== TRUE)
+      throw new TypeError(
+        `Condition of (${KEYWORDS.IF}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.IF
+        } ${stringifyArgs(args)})`
+      )
+    return condition
+      ? evaluate(args[1], env)
+      : args.length === 3
+      ? evaluate(args[2], env)
+      : 0
   },
   [KEYWORDS.NOT]: (args, env) => {
     if (args.length !== 1)
@@ -294,13 +416,13 @@ export const keywords = {
     if (typeof a !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.EQUAL}), first argument is not an ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.EQUAL}), second argument are not an ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
     return +(a === b)
@@ -317,13 +439,13 @@ export const keywords = {
     if (typeof a !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.LESS_THAN}), first argument is not an ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.LESS_THAN}), second argument are not an ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
       )
     return +(a < b)
@@ -340,14 +462,14 @@ export const keywords = {
     if (typeof a !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.GREATHER_THAN}), first argument is not an ${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         } (${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
           KEYWORDS.GREATHER_THAN
         } ${stringifyArgs(args)})`
       )
@@ -368,7 +490,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), first argument is not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), first argument is not an ${RUNTIME_TYPES.NUMBER} (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -376,7 +498,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -397,7 +519,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }), first argument is not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), first argument is not an ${RUNTIME_TYPES.NUMBER} (${
           KEYWORDS.LESS_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -405,7 +527,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
           KEYWORDS.LESS_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -459,32 +581,6 @@ export const keywords = {
       )
     return b
   },
-  [KEYWORDS.CALL_FUNCTION]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.CALL_FUNCTION
-        }) (>= 1 required) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
-      )
-    const [first, ...rest] = args
-    if (first[TYPE] === WORD && first[VALUE] in keywords)
-      throw new TypeError(
-        `Following argument of (${
-          KEYWORDS.CALL_FUNCTION
-        }) must not be an reserved word (${
-          KEYWORDS.CALL_FUNCTION
-        } ${stringifyArgs(args)})`
-      )
-    const apply = evaluate(first, env)
-    if (typeof apply !== 'function')
-      throw new TypeError(
-        `First argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
-          KEYWORDS.ANONYMOUS_FUNCTION
-        }) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
-      )
-
-    return apply(rest, env)
-  },
   [KEYWORDS.DEFINE_VARIABLE]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
@@ -513,171 +609,101 @@ export const keywords = {
     })
     return env[name]
   },
-  [KEYWORDS.BITWISE_AND]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_AND
-        }) (= 2 required). (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_AND}) are ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc & x)
+  [KEYWORDS.ANONYMOUS_FUNCTION]: (args, env) => {
+    const params = args.slice(0, -1)
+    const body = args.at(-1)
+    return (props = [], scope) => {
+      if (props.length !== params.length)
+        throw new RangeError(
+          `Incorrect number of arguments for (${
+            KEYWORDS.ANONYMOUS_FUNCTION
+          } ${stringifyArgs(params)}) are provided. (expects ${
+            params.length
+          } but got ${props.length}) (${
+            KEYWORDS.ANONYMOUS_FUNCTION
+          } ${stringifyArgs(args)})`
+        )
+      const localEnv = Object.create(env)
+      // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
+      for (let i = 0; i < props.length; ++i) {
+        const value = evaluate(props[i], scope)
+        Object.defineProperty(localEnv, params[i][VALUE], {
+          value,
+          writable: true
+        })
+      }
+      return evaluate(body, localEnv)
+    }
   },
-  [KEYWORDS.BITWISE_NOT]: (args, env) => {
-    if (args.length !== 1)
+  [KEYWORDS.CALL_FUNCTION]: (args, env) => {
+    if (!args.length)
       throw new RangeError(
         `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_NOT
-        }) (= 1 required). (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
+          KEYWORDS.CALL_FUNCTION
+        }) (>= 1 required) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
       )
-    const operand = evaluate(args[0], env)
-    if (typeof operand !== 'number')
+    const [first, ...rest] = args
+    if (first[TYPE] === WORD && first[VALUE] in keywords)
       throw new TypeError(
-        `Argument of (${KEYWORDS.BITWISE_NOT}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
-      )
-    return ~operand
-  },
-  [KEYWORDS.BITWISE_OR]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_OR
-        }) (= 2 required). (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
+        `Following argument of (${
+          KEYWORDS.CALL_FUNCTION
+        }) must not be an reserved word (${
+          KEYWORDS.CALL_FUNCTION
+        } ${stringifyArgs(args)})`
       )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number' || typeof b !== 'number')
+    const apply = evaluate(first, env)
+    if (typeof apply !== 'function')
       throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_OR}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
+        `First argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
+          KEYWORDS.ANONYMOUS_FUNCTION
+        }) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
       )
-    return a | b
+
+    return apply(rest, env)
   },
-  [KEYWORDS.BITWISE_XOR]: (args, env) => {
-    if (args.length !== 2)
+  [KEYWORDS.BLOCK]: (args, env) => {
+    if (!args.length)
       throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_XOR
-        }) (= 2 required). (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number' || typeof b !== 'number')
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_XOR}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
+        `Invalid number of arguments to (${KEYWORDS.BLOCK}) (>= 1 required) (${
+          KEYWORDS.BLOCK
+        } ${stringifyArgs(args)})`
       )
-    return a ^ b
+    return args.reduce((_, x) => evaluate(x, env), 0)
   },
-  [KEYWORDS.BITWISE_LEFT_SHIFT]: (args, env) => {
-    if (args.length !== 2)
+  [KEYWORDS.IS_ATOM]: (args, env) => {
+    if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_LEFT_SHIFT
-        }) (= 2 required). (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
-          args
-        )})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number' || typeof b !== 'number')
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
+        `Invalid number of arguments for (${
+          KEYWORDS.IS_ATOM
+        }) (= 1 required) (${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
       )
-    return a << b
+    return +(typeof evaluate(args[0], env) === 'number')
   },
-  [KEYWORDS.BITWISE_RIGHT_SHIFT]: (args, env) => {
-    if (args.length !== 2)
+  [KEYWORDS.IS_LAMBDA]: (args, env) => {
+    if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_RIGHT_SHIFT
-        }) (= 2 required). (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
-          args
-        )})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number' || typeof b !== 'number')
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
+        `Invalid number of arguments for (${
+          KEYWORDS.IS_LAMBDA
+        }) (= 1 required) (${KEYWORDS.IS_LAMBDA} ${stringifyArgs(args)})`
       )
-    return a >> b
+    return +(typeof evaluate(args[0], env) === 'function')
   },
-  [KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT]: (args, env) => {
-    if (args.length !== 2)
+  // Not sure about these
+  [KEYWORDS.THROW]: (args, env) => {
+    if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
-        }) (= 2 required). (${
-          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
+        `Invalid number of arguments to (${KEYWORDS.THROW}) (= 1 required) (${
+          KEYWORDS.THROW
         } ${stringifyArgs(args)})`
       )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number' || typeof b !== 'number')
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(args)})`
-      )
-    return a >>> b
-  },
-  [KEYWORDS.SET_ARRAY]: (args, env) => {
-    if (args.length !== 1 && args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.SET_ARRAY
-        }) (or 1 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
+    const expression = evaluate(args[0], env)
+    if (!Array.isArray(expression))
       throw new TypeError(
-        `First argument of (${KEYWORDS.SET_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) but got (${array}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        `Argument of (${KEYWORDS.THROW}) must be an (${
+          RUNTIME_TYPES.ARRAY
+        }) but got (${expression}) (${KEYWORDS.THROW} ${stringifyArgs(args)})`
       )
-    if (args.length === 1) {
-      array.pop()
-    } else {
-      const index = evaluate(args[1], env)
-      if (!Number.isInteger(index) || index < 0)
-        throw new TypeError(
-          `Second argument of (${KEYWORDS.SET_ARRAY}) must be a positive (${
-            KEYWORDS.NUMBER_TYPE
-          } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-        )
-      if (index > array.length)
-        throw new RangeError(
-          `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
-            KEYWORDS.ARRAY_TYPE
-          }) bounds (index ${index} bounds ${array.length}) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      const value = evaluate(args[2], env)
-      if (value == undefined)
-        throw new RangeError(
-          `Trying to set a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
-            KEYWORDS.SET_ARRAY
-          }). (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-        )
-      array[index] = value
-    }
-    return array
+    throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   },
   [KEYWORDS.LOG]: (args, env) => {
     if (args.length !== 1)
@@ -701,7 +727,7 @@ export const keywords = {
     if (!Array.isArray(expression))
       throw new TypeError(
         `Argument of (${KEYWORDS.LOG_STRING}) must be an (${
-          KEYWORDS.ARRAY_TYPE
+          RUNTIME_TYPES.ARRAY
         }) but got (${expression}) (${KEYWORDS.LOG_STRING} ${stringifyArgs(
           args
         )})`
@@ -720,7 +746,7 @@ export const keywords = {
     if (typeof expression !== 'number')
       throw new TypeError(
         `Argument of (${KEYWORDS.LOG_CHAR}) must be a (${
-          KEYWORDS.NUMBER_TYPE
+          RUNTIME_TYPES.NUMBER
         }) but got (${expression}) (${KEYWORDS.LOG_CHAR} ${stringifyArgs(
           args
         )})`
@@ -737,23 +763,5 @@ export const keywords = {
       )
     console.clear()
     return 0
-  },
-
-  // Not sure about these
-  [KEYWORDS.THROW]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.THROW}) (= 1 required) (${
-          KEYWORDS.THROW
-        } ${stringifyArgs(args)})`
-      )
-    const expression = evaluate(args[0], env)
-    if (!Array.isArray(expression))
-      throw new TypeError(
-        `Argument of (${KEYWORDS.THROW}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) but got (${expression}) (${KEYWORDS.THROW} ${stringifyArgs(args)})`
-      )
-    throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   }
 }

package/src/keywords.js

@@ -7,8 +7,7 @@ export const TRUE = 1
 export const FALSE = 0
 export const PLACEHOLDER = '.'
 export const KEYWORDS = {
-  NUMBER_TYPE: 'number',
-  ARRAY_TYPE: 'array',
+  CREATE_ARRAY: 'array',
   IDENTITY: 'identity',
   ARRAY_LENGTH: 'length',
   IS_ATOM: 'atom?',
@@ -56,3 +55,7 @@ export const TYPES = {
   [WORD]: 'WORD',
   [ATOM]: 'ATOM'
 }
+export const RUNTIME_TYPES = {
+  NUMBER: 'number',
+  ARRAY: 'array'
+}

package/src/macros.js

@@ -25,9 +25,7 @@ export const SUGGAR = {
   LIST_TYPE: 'list',
   POWER: '**',
   INTEGER_DEVISION: '//',
-  CONDITION: 'cond',
-  RECURSION: 'recursive',
-  CACHE: 'memoized'
+  CONDITION: 'cond'
 }
 export const deSuggarAst = (ast) => {
   if (ast.length === 0) throw new SyntaxError(`No expressions to evaluate`)
@@ -148,10 +146,10 @@ export const deSuggarAst = (ast) => {
                   exp.length = 0
                   let temp = exp
                   for (const item of rest) {
-                    temp.push([APPLY, KEYWORDS.ARRAY_TYPE], item, [])
+                    temp.push([APPLY, KEYWORDS.CREATE_ARRAY], item, [])
                     temp = temp.at(-1)
                   }
-                  temp.push([APPLY, KEYWORDS.ARRAY_TYPE])
+                  temp.push([APPLY, KEYWORDS.CREATE_ARRAY])
                 }
                 deSuggarAst(exp)
                 break
@@ -388,7 +386,7 @@ export const replaceStrings = (source) => {
     for (const q of quotes)
       source = source.replaceAll(
         q,
-        `(${KEYWORDS.ARRAY_TYPE} ${[...q.replaceAll('\r', '')]
+        `(${KEYWORDS.CREATE_ARRAY} ${[...q.replaceAll('\r', '')]
           .slice(1, -1)
           .map((x) => x.charCodeAt(0))
           .join(' ')})`
@@ -397,9 +395,9 @@ export const replaceStrings = (source) => {
 }
 export const replaceQuotes = (source) =>
   source
-    .replaceAll(/\'\(/g, `(${KEYWORDS.ARRAY_TYPE} `)
+    .replaceAll(/\'\(/g, `(${KEYWORDS.CREATE_ARRAY} `)
     .replaceAll(/\`\(/g, `(${SUGGAR.LIST_TYPE} `)
-    .replaceAll(/\(\)/g, `(${KEYWORDS.ARRAY_TYPE})`)
+    .replaceAll(/\(\)/g, `(${KEYWORDS.CREATE_ARRAY})`)
 export const deSuggarSource = (source) => replaceQuotes(replaceStrings(source))
 export const handleUnbalancedQuotes = (source) => {
   const diff = (source.match(/\"/g) ?? []).length % 2

package/src/utils.js

@@ -1,13 +1,12 @@
 import std from '../lib/baked/std.js'
-import { comp } from './compiler.js'
+import { comp, OPTIMIZATIONS } from './compiler.js'
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
 import { evaluate, run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 import {
   deSuggarAst,
   deSuggarSource,
-  handleUnbalancedQuotes,
-  SUGGAR
+  handleUnbalancedQuotes
 } from './macros.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
@@ -59,7 +58,7 @@ export const stringifyType = (type) => {
   if (!isLeaf(type)) {
     const [car] = type
     if (car == undefined) return '(array)'
-    else if (car[TYPE] === APPLY && car[VALUE] === KEYWORDS.ARRAY_TYPE)
+    else if (car[TYPE] === APPLY && car[VALUE] === KEYWORDS.CREATE_ARRAY)
       return `(array ${type
         .map((t) => stringifyType(t))
         .join(' ')
@@ -84,15 +83,18 @@ export const stringifyArgs = (args) =>
             .replace(new RegExp(/"/g), '')
     )
     .join(' ')
+const KEYWORDS_SET = Object.values(KEYWORDS).reduce((a, b) => {
+  a.add(b)
+  return a
+}, new Set())
 export const isForbiddenVariableName = (name) => {
   switch (name) {
     case '_':
-    case KEYWORDS.DEFINE_VARIABLE:
-    case SUGGAR.RECURSION:
-    case SUGGAR.CACHE:
+    case OPTIMIZATIONS.RECURSION:
+    case OPTIMIZATIONS.CACHE:
       return true
     default:
-      return !isNaN(name[0])
+      return KEYWORDS_SET.has(name) || !isNaN(name[0])
   }
 }
 export const isEqual = (a, b) =>