fez-lisp 1.2.33 → 1.2.35

package/package.json

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

package/src/compiler.js

@@ -109,7 +109,8 @@ const Helpers = {
   __tco: `__tco=fn=>(...args)=>{let result=fn(...args);while(typeof result==='function')result=result();return result}`,
   atom_predicate: `atom_predicate=(number)=>+(typeof number==='number')`,
   lambda_predicate: `lambda_predicate=(fm)=>+(typeof fn==='function')`,
-  set_effect: `set_effect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
+  set_effect: `set_effect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`,
+  __error: `__error=(error)=>{throw new Error(error.map((x)=>String.fromCharCode(x)).join(''))}`
 }
 const semiColumnEdgeCases = new Set([
   ';)',
@@ -141,6 +142,8 @@ const compile = (tree, Drill) => {
   const token = first[VALUE]
   if (first[TYPE] === APPLY) {
     switch (token) {
+      case KEYWORDS.ASSERT:
+        return '0'
       case KEYWORDS.BLOCK: {
         if (Arguments.length > 1) {
           return `(${Arguments.map((x) =>
@@ -292,12 +295,10 @@ const compile = (tree, Drill) => {
         out += '0);'
         return out
       }
-      // case KEYWORDS.PIPE: {
-      //   let inp = Arguments[0]
-      //   for (let i = 1; i < Arguments.length; ++i)
-      //     inp = [Arguments[i].shift(), inp, ...Arguments[i]]
-      //   return compile(inp, Drill)
-      // }
+      case KEYWORDS.THROW: {
+        Drill.Helpers.add('__error')
+        return `__error(${compile(Arguments[0], Drill)})`
+      }
       default: {
         const camelCased = lispToJavaScriptVariableName(token)
         if (camelCased in Helpers) Drill.Helpers.add(camelCased)

package/src/interpreter.js

@@ -3,14 +3,12 @@ import {
   VALUE,
   WORD,
   KEYWORDS,
-  APPLY,
-  ATOM,
   FALSE,
   TRUE,
-  TYPES
+  TYPES,
+  APPLY
 } from './keywords.js'
 import { evaluate } from './evaluator.js'
-import { isLeaf } from './parser.js'
 import { isForbiddenVariableName, stringifyArgs } from './utils.js'
 const keywords = {
   [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
@@ -172,7 +170,9 @@ const keywords = {
     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}`
+        `Condition of (${KEYWORDS.IF}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.IF
+        } ${stringifyArgs(args)})`
       )
     return condition
       ? evaluate(args[1], env)
@@ -201,7 +201,11 @@ const keywords = {
       const condition = evaluate(args[i], env)
       if (condition !== FALSE && condition !== TRUE)
         throw new TypeError(
-          `Condition of (${KEYWORDS.CONDITION}) must be ${TRUE} or ${FALSE} but got ${condition}`
+          `Condition of (${
+            KEYWORDS.CONDITION
+          }) must be ${TRUE} or ${FALSE} but got (${
+            KEYWORDS.CONDITION
+          } ${stringifyArgs(args)})`
         )
       if (condition) return evaluate(args[i + 1], env)
     }
@@ -437,7 +441,11 @@ const keywords = {
       circuit = evaluate(args[i], env)
       if (circuit !== FALSE && circuit !== TRUE)
         throw new TypeError(
-          `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got ${circuit}`
+          `Condition of (${
+            KEYWORDS.AND
+          }) must be ${TRUE} or ${FALSE} but got (${
+            KEYWORDS.AND
+          } ${stringifyArgs(args)})`
         )
       if (circuit) continue
       else return 0
@@ -445,7 +453,9 @@ const keywords = {
     const end = evaluate(args.at(-1), env)
     if (end !== FALSE && end !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got ${end}`
+        `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.AND
+        } ${stringifyArgs(args)})`
       )
     return end
   },
@@ -461,7 +471,9 @@ const keywords = {
       circuit = evaluate(args[i], env)
       if (circuit !== FALSE && circuit !== TRUE)
         throw new TypeError(
-          `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got ${circuit}`
+          `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+            KEYWORDS.OR
+          } ${stringifyArgs(args)})`
         )
       if (circuit) return 1
       else continue
@@ -469,7 +481,9 @@ const keywords = {
     const end = evaluate(args.at(-1), env)
     if (end !== FALSE && end !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got ${end}`
+        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.OR
+        } ${stringifyArgs(args)})`
       )
     return end
   },
@@ -795,8 +809,67 @@ 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(''))
+  },
+
+  [KEYWORDS.ASSERT]: (args, env) => {
+    if (args.length < 2)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.ASSERT
+        }), expected (> 2 required) but got ${args.length} (${
+          KEYWORDS.ASSERT
+        } ${stringifyArgs(args)})`
+      )
+    if (args.length % 2 !== 0)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.ASSERT
+        }), expected even number of arguments but got ${args.length} (${
+          KEYWORDS.ASSERT
+        } ${stringifyArgs(args)})`
+      )
+    for (let i = 0; i < args.length; i += 2) {
+      const condition = evaluate(args[i], env)
+      if (condition !== FALSE && condition !== TRUE)
+        throw new TypeError(
+          `Condition of (${
+            KEYWORDS.ASSERT
+          }) must be ${TRUE} or ${FALSE} but got (${
+            KEYWORDS.ASSERT
+          } ${stringifyArgs(args)})`
+        )
+      if (condition) {
+        const error = args[i + 1]
+        if (error[0][TYPE] === APPLY && error[0][VALUE] === KEYWORDS.THROW)
+          return evaluate(error, env)
+        else
+          throw new TypeError(
+            `Concequence of (${KEYWORDS.ASSERT}) must be (${
+              KEYWORDS.THROW
+            }) but got (${KEYWORDS.ASSERT} ${stringifyArgs(args)})`
+          )
+      }
+    }
+    return 0
   }
 }
-keywords[KEYWORDS.NOT_COMPILED_BLOCK] = keywords[KEYWORDS.BLOCK]
 
 export { keywords }

package/src/keywords.js

@@ -44,12 +44,14 @@ export const KEYWORDS = {
 
   SET_ARRAY: 'set!',
 
-  NOT_COMPILED_BLOCK: 'void',
   LOG: 'log!',
   LOG_STRING: 'log-string!',
   LOG_CHAR: 'log-char!',
   CLEAR_CONSOLE: 'clear!',
 
+  THROW: 'throw',
+  ASSERT: 'assert',
+
   // Syntactic suggars
   PIPE: '|>',
   NOT_EQUAL_1: '!=',

package/src/utils.js

@@ -70,7 +70,7 @@ export const stringifyArrayTypes = (type) =>
     : 'number'
 export const stringifyType = (type) => {
   if (!isLeaf(type)) {
-    const [car, ...cdr] = type
+    const [car] = type
     if (car == undefined) return '(array)'
     else if (car[TYPE] === APPLY && car[VALUE] === KEYWORDS.ARRAY_TYPE)
       return `(array ${type