fez-lisp 1.3.27 → 1.4.0

package/src/interpreter.js

@@ -10,13 +10,14 @@ import {
 } from './keywords.js'
 import { evaluate } from './evaluator.js'
 import { isForbiddenVariableName, stringifyArgs } from './utils.js'
+import { LISP } from './parser.js'
 export const keywords = {
   [KEYWORDS.ADDITION]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.ADDITION
-        }), expected (= 2) but got ${args.length}. (${
+        }), expected (= 2) but got ${args.length}\n\nat:\n(${
           KEYWORDS.ADDITION
         } ${stringifyArgs(args)})`
       )
@@ -25,35 +26,39 @@ export const keywords = {
       throw new TypeError(
         `First arguments of (${KEYWORDS.ADDITION}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
       )
     const b = evaluate(args[1], env)
     if (typeof b !== 'number')
       throw new TypeError(
         `Second arguments of (${KEYWORDS.ADDITION}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
       )
     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}.`
+        `Invalid number of arguments for (${
+          KEYWORDS.MULTIPLICATION
+        }), expected (= 2) but got ${args.length}\n\nat:\n(${
+          KEYWORDS.MULTIPLICATION
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
       throw new TypeError(
         `First arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${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)})`
+        })\n\nat:\n(${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
       )
     return a * b
   },
@@ -62,7 +67,7 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.SUBTRACTION
-        }), expected (or (= 1)) (= 2) but got ${args.length}. (${
+        }), expected (or (= 1) (= 2)) but got ${args.length}\n\nat:\n(${
           KEYWORDS.SUBTRACTION
         } ${stringifyArgs(args)})`
       )
@@ -71,7 +76,7 @@ export const keywords = {
       throw new TypeError(
         `First argument of (${KEYWORDS.SUBTRACTION}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
       )
     if (args.length === 1) return -a
     const b = evaluate(args[1], env)
@@ -79,34 +84,38 @@ export const keywords = {
       throw new TypeError(
         `Second argument of (${KEYWORDS.SUBTRACTION}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
       )
     return a - b
   },
   [KEYWORDS.DIVISION]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.DIVISION}), expected (= 2) but got ${args.length}.`
+        `Invalid number of arguments for (${
+          KEYWORDS.DIVISION
+        }), expected (= 2) but got ${args.length}\n\nat:\n(${
+          KEYWORDS.DIVISION
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
       throw new TypeError(
         `First argument of (${KEYWORDS.DIVISION}) is not (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
       )
     const b = evaluate(args[1], env)
     if (typeof b !== 'number')
       throw new TypeError(
         `Second argument of (${KEYWORDS.DIVISION}) is not (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
       )
     if (b === 0)
       throw new TypeError(
         `Second Argument of (${
           KEYWORDS.DIVISION
-        }) can't be a (0) (division by 0 is not allowed) (${
+        }) can't be a (0) (division by 0 is not allowed)\n\nat:\n(${
           KEYWORDS.DIVISION
         } ${stringifyArgs(args)})`
       )
@@ -117,7 +126,7 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.REMAINDER_OF_DIVISION
-        }), expected (= 2) but got ${args.length}. (${
+        }), expected (= 2) but got ${args.length}\n\nat:\n(${
           KEYWORDS.REMAINDER_OF_DIVISION
         } ${stringifyArgs(args)})`
       )
@@ -126,20 +135,20 @@ export const keywords = {
       throw new TypeError(
         `First argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
       )
     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)})`
+        })\n\nat:\n(${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) (${
+        }) can't be a (0) (division by 0 is not allowed)\n\nat:\n(${
           KEYWORDS.REMAINDER_OF_DIVISION
         } ${stringifyArgs(args)})`
       )
@@ -151,21 +160,23 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_AND
-        }) (= 2 required). (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
       throw new TypeError(
         `First arguments of (${KEYWORDS.BITWISE_AND}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
       )
     const b = evaluate(args[1], env)
     if (typeof b !== 'number')
       throw new TypeError(
         `Second arguments of (${KEYWORDS.BITWISE_AND}) is not a (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
       )
     return a & b
   },
@@ -174,14 +185,16 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_NOT
-        }) (= 1 required). (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
+        }) (= 1 required)\n\nat:\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(
+          args
+        )})`
       )
     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)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
       )
     return ~operand
   },
@@ -190,7 +203,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_OR
-        }) (= 2 required). (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -198,7 +213,7 @@ export const keywords = {
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.BITWISE_OR}) are (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
       )
     return a | b
   },
@@ -207,7 +222,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_XOR
-        }) (= 2 required). (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -215,7 +232,7 @@ export const keywords = {
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.BITWISE_XOR}) are (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
       )
     return a ^ b
   },
@@ -224,9 +241,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_LEFT_SHIFT
-        }) (= 2 required). (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
-          args
-        )})`
+        }) (= 2 required)\n\nat:\n(${
+          KEYWORDS.BITWISE_LEFT_SHIFT
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -234,7 +251,7 @@ export const keywords = {
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) are (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
       )
     return a << b
   },
@@ -243,9 +260,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_RIGHT_SHIFT
-        }) (= 2 required). (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
-          args
-        )})`
+        }) (= 2 required)\n\nat:\n(${
+          KEYWORDS.BITWISE_RIGHT_SHIFT
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -253,7 +270,7 @@ export const keywords = {
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) are (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
       )
     return a >> b
   },
@@ -262,7 +279,7 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
-        }) (= 2 required). (${
+        }) (= 2 required)\n\nat:\n(${
           KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
         } ${stringifyArgs(args)})`
       )
@@ -272,7 +289,9 @@ export const keywords = {
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT}) are (${
           RUNTIME_TYPES.NUMBER
-        }) (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
+          args
+        )})`
       )
     return a >>> b
   },
@@ -284,40 +303,48 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.GET_ARRAY
-        }) (= 2 required) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(
+          args
+        )})`
       )
     const array = evaluate(args[0], env)
     if (!Array.isArray(array))
       throw new TypeError(
         `First argument of (${KEYWORDS.GET_ARRAY}) must be an (${
           RUNTIME_TYPES.ARRAY
-        })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     if (array.length === 0)
       throw new RangeError(
         `First argument of (${KEYWORDS.GET_ARRAY}) is an empty (${
           RUNTIME_TYPES.ARRAY
-        })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)}))`
+        })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     const index = evaluate(args[1], env)
-    if (!Number.isInteger(index))
+    if (!Number.isInteger(index) || index < 0)
       throw new TypeError(
-        `Second argument of (${KEYWORDS.GET_ARRAY}) must be an (32 bit ${
+        `Second argument of (${
+          KEYWORDS.GET_ARRAY
+        }) must be a positive (32 bit ${
           RUNTIME_TYPES.NUMBER
-        }) (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
+        }) (= i ${index})\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(
+          args
+        )})`
       )
-    if (index > array.length - 1 || index * -1 > array.length)
+    if (index > array.length - 1)
       throw new RangeError(
         `Second argument of (${KEYWORDS.GET_ARRAY}) is outside of (${
           RUNTIME_TYPES.ARRAY
-        }) bounds (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
+        }) bounds (= i ${index}) expected (and (>= i 0) (< i ${
+          array.length
+        }))\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     const value = array.at(index)
     if (value == undefined)
       throw new RangeError(
         `Trying to get a null value in (${RUNTIME_TYPES.ARRAY}) at (${
           KEYWORDS.GET_ARRAY
-        }) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
       )
     return value
   },
@@ -326,14 +353,18 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.SET_ARRAY
-        }) (or 1 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        }) (or 1 3) required\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(
+          args
+        )})`
       )
     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)})`
+        }) but got (${array})\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(
+          args
+        )})`
       )
     if (args.length === 1) {
       array.pop()
@@ -343,22 +374,24 @@ export const keywords = {
         throw new TypeError(
           `Second argument of (${KEYWORDS.SET_ARRAY}) must be a positive (${
             RUNTIME_TYPES.NUMBER
-          } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+          } integer) (= i ${index})\n\nat:\n(${
+            KEYWORDS.SET_ARRAY
+          } ${stringifyArgs(args)})`
         )
       if (index > array.length)
         throw new RangeError(
           `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
             RUNTIME_TYPES.ARRAY
-          }) bounds (index ${index} bounds ${array.length}) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
+          }) bounds (${index}) expected (and (>= i 0) (< i ${
+            array.length
+          }))\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
         )
       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)})`
+          })\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
         )
       array[index] = value
     }
@@ -369,14 +402,16 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.ARRAY_LENGTH
-        }) (= 1 required) (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
+        }) (= 1 required)\n\nat:\n(${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)})`
+        }\n\nat:\n(${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
       )
     return array.length
   },
@@ -385,16 +420,18 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.IF
-        }), expected (or (= 3) (= 2)) but got ${args.length} (${
+        }), expected (or (= 3) (= 2)) but got ${args.length}\n\nat:\n(${
           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 (${
+        `Condition of (${
           KEYWORDS.IF
-        } ${stringifyArgs(args)})`
+        }) must be ${TRUE} or ${FALSE} but got ${LISP.source(
+          args[0]
+        )}\n\nat:\n(${KEYWORDS.IF} ${stringifyArgs(args)})`
       )
     return condition
       ? evaluate(args[1], env)
@@ -405,25 +442,27 @@ export const keywords = {
   [KEYWORDS.NOT]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.NOT}) (= 1 required) (${
+        `Invalid number of arguments for (${
           KEYWORDS.NOT
-        } ${stringifyArgs(args)})`
+        }) (= 1 required)\n\nat:\n(${KEYWORDS.NOT} ${stringifyArgs(args)})`
       )
     const operand = evaluate(args[0], env)
     if (operand !== FALSE && operand !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.NOT}) must be ${TRUE} or ${FALSE} but got (${
+        `Condition of (${
           KEYWORDS.NOT
-        } ${stringifyArgs(args)})`
+        }) must be ${TRUE} or ${FALSE} but got ${LISP.source(
+          args[0]
+        )}\n\nat:\n(${KEYWORDS.NOT} ${stringifyArgs(args)})`
       )
     return +!evaluate(args[0], env)
   },
   [KEYWORDS.EQUAL]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.EQUAL}) (= 2 required) (${
+        `Invalid number of arguments for (${
           KEYWORDS.EQUAL
-        } ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -431,13 +470,13 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${KEYWORDS.EQUAL}), first argument is not an ${
           RUNTIME_TYPES.NUMBER
-        } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.EQUAL}), second argument are not an ${
           RUNTIME_TYPES.NUMBER
-        } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
     return +(a === b)
   },
@@ -446,7 +485,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.LESS_THAN
-        }) (= 2 required) (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -454,13 +495,13 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${KEYWORDS.LESS_THAN}), first argument is not an ${
           RUNTIME_TYPES.NUMBER
-        } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${KEYWORDS.LESS_THAN}), second argument are not an ${
           RUNTIME_TYPES.NUMBER
-        } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
       )
     return +(a < b)
   },
@@ -469,7 +510,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.GREATHER_THAN
-        }) (= 2 required) (${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(
+          args
+        )})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -477,13 +520,13 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${KEYWORDS.GREATHER_THAN}), first argument is not an ${
           RUNTIME_TYPES.NUMBER
-        } (${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN
-        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
           KEYWORDS.GREATHER_THAN
         } ${stringifyArgs(args)})`
       )
@@ -494,9 +537,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }) (= 2 required) (${KEYWORDS.GREATHER_THAN_OR_EQUAL} ${stringifyArgs(
-          args
-        )})`
+        }) (= 2 required)\n\nat:\n(${
+          KEYWORDS.GREATHER_THAN_OR_EQUAL
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -504,7 +547,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), first argument is not an ${RUNTIME_TYPES.NUMBER} (${
+        }), first argument is not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -512,7 +555,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -523,9 +566,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }) (= 2 required) (${KEYWORDS.LESS_THAN_OR_EQUAL} ${stringifyArgs(
-          args
-        )})`
+        }) (= 2 required)\n\nat:\n(${
+          KEYWORDS.LESS_THAN_OR_EQUAL
+        } ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     const b = evaluate(args[1], env)
@@ -533,7 +576,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }), first argument is not an ${RUNTIME_TYPES.NUMBER} (${
+        }), first argument is not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
           KEYWORDS.LESS_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -541,7 +584,7 @@ export const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }), second argument are not an ${RUNTIME_TYPES.NUMBER} (${
+        }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
           KEYWORDS.LESS_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -550,14 +593,16 @@ export const keywords = {
   [KEYWORDS.AND]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.AND}) (= 2 required) (${
+        `Invalid number of arguments for (${
           KEYWORDS.AND
-        } ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.AND} ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     if (a !== FALSE && a !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got (${
+        `Condition of (${
+          KEYWORDS.AND
+        }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
           KEYWORDS.AND
         } ${stringifyArgs(args)})`
       )
@@ -565,7 +610,9 @@ export const keywords = {
     const b = evaluate(args[1], env)
     if (b !== FALSE && b !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got (${
+        `Condition of (${
+          KEYWORDS.AND
+        }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
           KEYWORDS.AND
         } ${stringifyArgs(args)})`
       )
@@ -574,14 +621,16 @@ export const keywords = {
   [KEYWORDS.OR]: (args, env) => {
     if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.OR}) (= 2 required) (${
+        `Invalid number of arguments for (${
           KEYWORDS.OR
-        } ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.OR} ${stringifyArgs(args)})`
       )
     const a = evaluate(args[0], env)
     if (a !== FALSE && a !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+        `Condition of (${
+          KEYWORDS.OR
+        }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
           KEYWORDS.OR
         } ${stringifyArgs(args)})`
       )
@@ -589,7 +638,9 @@ export const keywords = {
     const b = evaluate(args[1], env)
     if (b !== FALSE && b !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+        `Condition of (${
+          KEYWORDS.OR
+        }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
           KEYWORDS.OR
         } ${stringifyArgs(args)})`
       )
@@ -600,7 +651,9 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.DEFINE_VARIABLE
-        }) (= 2 required) (${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
+        }) (= 2 required)\n\nat:\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(
+          args
+        )})`
       )
     const word = args[0]
     const type = word[TYPE]
@@ -609,11 +662,11 @@ export const keywords = {
       throw new SyntaxError(
         `First argument of (${KEYWORDS.DEFINE_VARIABLE}) must be word but got ${
           TYPES[type]
-        } (${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
+        }\n\nat:\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
       )
     else if (isForbiddenVariableName(name))
       throw new ReferenceError(
-        `Variable name ${name} is forbidden at (${
+        `Variable name ${name} is forbidden at\n\nat:\n(${
           KEYWORDS.DEFINE_VARIABLE
         } ${stringifyArgs(args)})`
       )
@@ -626,16 +679,14 @@ export const keywords = {
   [KEYWORDS.ANONYMOUS_FUNCTION]: (args, env) => {
     const params = args.slice(0, -1)
     const body = args.at(-1)
-    return (props = [], scope) => {
+    return (props = [], scope, name) => {
       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)})`
+          `Incorrect number of arguments for (${KEYWORDS.ANONYMOUS_FUNCTION}${
+            name ? ` ${name}` : ''
+          }) are provided (expects ${params.length} but got ${
+            props.length
+          })\n\nat:\n(${KEYWORDS.ANONYMOUS_FUNCTION} ${stringifyArgs(params)})`
         )
       const localEnv = Object.create(env)
       // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
@@ -646,6 +697,7 @@ export const keywords = {
           writable: true
         })
       }
+      if (name) evaluate.stack.push(name)
       return evaluate(body, localEnv)
     }
   },
@@ -654,15 +706,16 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.CALL_FUNCTION
-        }) (>= 1 required) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
+        }) (>= 1 required)\n\nat:\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(
+          args
+        )})`
       )
-    const rest = [...args]
-    const first = rest.pop()
+    const first = args.at(-1)
     if (first[TYPE] === WORD && first[VALUE] in keywords)
       throw new TypeError(
         `Preceeding arguments of (${
           KEYWORDS.CALL_FUNCTION
-        }) must not be an reserved word (${
+        }) must not be an reserved word\n\nat:\n(${
           KEYWORDS.CALL_FUNCTION
         } ${stringifyArgs(args)})`
       )
@@ -671,17 +724,17 @@ export const keywords = {
       throw new TypeError(
         `Last argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
           KEYWORDS.ANONYMOUS_FUNCTION
-        }) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
+        })\n\nat:\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
       )
 
-    return apply(rest, env)
+    return apply(args.slice(0, -1), env)
   },
   [KEYWORDS.BLOCK]: (args, env) => {
     if (!args.length)
       throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.BLOCK}) (>= 1 required) (${
+        `Invalid number of arguments to (${
           KEYWORDS.BLOCK
-        } ${stringifyArgs(args)})`
+        }) (>= 1 required)\n\nat:\n(${KEYWORDS.BLOCK} ${stringifyArgs(args)})`
       )
     return args.reduce((_, x) => evaluate(x, env), FALSE)
   },
@@ -690,7 +743,7 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.IS_ATOM
-        }) (= 1 required) (${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
+        }) (= 1 required)\n\nat:\n(${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
       )
     return +(typeof evaluate(args[0], env) === 'number')
   },
@@ -699,67 +752,10 @@ export const keywords = {
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.IS_LAMBDA
-        }) (= 1 required) (${KEYWORDS.IS_LAMBDA} ${stringifyArgs(args)})`
-      )
-    return +(typeof evaluate(args[0], env) === 'function')
-  },
-  [KEYWORDS.LOG]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.LOG}) (= 1 required) (${
-          KEYWORDS.LOG
-        } ${stringifyArgs(args)})`
-      )
-    const expression = evaluate(args[0], env)
-    console.log(expression)
-    return expression
-  },
-  [KEYWORDS.LOG_STRING]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.LOG_STRING
-        }) (= 1 required) (${KEYWORDS.LOG_STRING} ${stringifyArgs(args)})`
-      )
-    const expression = evaluate(args[0], env)
-    if (!Array.isArray(expression))
-      throw new TypeError(
-        `Argument of (${KEYWORDS.LOG_STRING}) must be an (${
-          RUNTIME_TYPES.ARRAY
-        }) but got (${expression}) (${KEYWORDS.LOG_STRING} ${stringifyArgs(
+        }) (= 1 required)\n\nat:\n(${KEYWORDS.IS_LAMBDA} ${stringifyArgs(
           args
         )})`
       )
-    console.log(expression.map((x) => String.fromCharCode(x)).join(''))
-    return expression
-  },
-  [KEYWORDS.LOG_CHAR]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.LOG_CHAR
-        }) (= 1 required) (${KEYWORDS.LOG_CHAR} ${stringifyArgs(args)})`
-      )
-    const expression = evaluate(args[0], env)
-    if (typeof expression !== 'number')
-      throw new TypeError(
-        `Argument of (${KEYWORDS.LOG_CHAR}) must be a (${
-          RUNTIME_TYPES.NUMBER
-        }) but got (${expression}) (${KEYWORDS.LOG_CHAR} ${stringifyArgs(
-          args
-        )})`
-      )
-    console.log(String.fromCharCode(expression))
-    return expression
-  },
-  [KEYWORDS.CLEAR_CONSOLE]: (args) => {
-    if (args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.CLEAR_CONSOLE
-        }) (= 0 required) (${KEYWORDS.CLEAR_CONSOLE} ${stringifyArgs(args)})`
-      )
-    console.clear()
-    return 0
+    return +(typeof evaluate(args[0], env) === 'function')
   }
 }