fez-lisp 1.5.19 → 1.5.21

package/package.json

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

package/src/check.js

@@ -224,7 +224,7 @@ export const typeCheck = (ast) => {
     [KEYWORDS.SET_ARRAY]: {
       [STATS]: {
         type: APPLY,
-        [ARGS_COUNT]: new Set([1, 3]),
+        [ARGS_COUNT]: new Set([3]),
         [ARGS]: [
           [UNKNOWN, PLACEHOLDER],
           [ATOM, PLACEHOLDER],
@@ -233,6 +233,14 @@ export const typeCheck = (ast) => {
         [RETURNS]: UNKNOWN
       }
     },
+    [KEYWORDS.POP_ARRAY]: {
+      [STATS]: {
+        type: APPLY,
+        [ARGS_COUNT]: new Set([1]),
+        [ARGS]: [[UNKNOWN, PLACEHOLDER]],
+        [RETURNS]: UNKNOWN
+      }
+    },
     [KEYWORDS.ARRAY_LENGTH]: {
       [STATS]: {
         type: APPLY,
@@ -244,7 +252,7 @@ export const typeCheck = (ast) => {
     [KEYWORDS.IF]: {
       [STATS]: {
         type: APPLY,
-        [ARGS_COUNT]: new Set([2, 3]),
+        [ARGS_COUNT]: new Set([3]),
         [ARGS]: [
           [ATOM, PLACEHOLDER, PREDICATE],
           [UNKNOWN, PLACEHOLDER],

package/src/compiler.js

@@ -112,7 +112,8 @@ const Helpers = {
   atom_predicate: `atom_predicate=(number)=>+(typeof number==='number')`,
   lambda_predicate: `lambda_predicate=(fn)=>+(typeof fn==='function')`,
   __error: `__error=(error)=>{throw new Error(error.map((x)=>String.fromCharCode(x)).join(''))}`,
-  alter_effect: `alter_effect=function(array,index,value){if(arguments.length===1){array.pop()}else{array[index] = value};return array}`
+  set_effect: `set_effect=(array,index,value)=>{array[index] = value;return array}`,
+  pop_effect: `pop_effect=(array)=>{array.pop();return array}`
 }
 const semiColumnEdgeCases = new Set([
   ';)',
@@ -250,9 +251,10 @@ const comp = (tree, Drill) => {
       case KEYWORDS.NOT:
         return `(+!${comp(tail[0], Drill)})`
       case KEYWORDS.IF: {
-        return `(${comp(tail[0], Drill)}?${comp(tail[1], Drill)}:${
-          tail.length === 3 ? comp(tail[2], Drill) : 0
-        });`
+        return `(${comp(tail[0], Drill)}?${comp(tail[1], Drill)}:${comp(
+          tail[2],
+          Drill
+        )});`
       }
       case KEYWORDS.LOOP: {
         return `(()=>{while(${comp(tail[0], Drill)}){${comp(

package/src/interpreter.js

@@ -389,11 +389,11 @@ export const keywords = {
     return value
   },
   [KEYWORDS.SET_ARRAY]: (args, env) => {
-    if (args.length !== 1 && args.length !== 3)
+    if (args.length !== 3)
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.SET_ARRAY
-        }) (or 1 3) required\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        }) (= 3) required\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
       )
     const array = evaluate(args[0], env)
     if (!Array.isArray(array))
@@ -404,37 +404,52 @@ export const keywords = {
           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) (= i ${index}) but ${LISP.source(args[1])} is not\n\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}) expected (and (>= i 0) (< i ${
-            array.length
-          })) but ${LISP.source(args[1])} is not\n\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
-          })\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-        )
-      array[index] = value
-    }
+    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) (= i ${index}) but ${LISP.source(args[1])} is not\n\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}) expected (and (>= i 0) (< i ${
+          array.length
+        })) but ${LISP.source(args[1])} is not\n\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
+        })\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+      )
+    array[index] = value
+    return array
+  },
+  [KEYWORDS.POP_ARRAY]: (args, env) => {
+    if (args.length !== 1)
+      throw new RangeError(
+        `Invalid number of arguments for (${
+          KEYWORDS.POP_ARRAY
+        }) (= 1) required\n\n(${KEYWORDS.POP_ARRAY} ${stringifyArgs(args)})`
+      )
+    const array = evaluate(args[0], env)
+    if (!Array.isArray(array))
+      throw new TypeError(
+        `First argument of (${KEYWORDS.POP_ARRAY}) must be an (${
+          RUNTIME_TYPES.ARRAY
+        }) but ${LISP.source(args[0])} is not\n\n(${
+          KEYWORDS.POP_ARRAY
+        } ${stringifyArgs(args)})`
+      )
+    array.pop()
     return array
   },
   [KEYWORDS.ARRAY_LENGTH]: (args, env) => {
@@ -456,11 +471,11 @@ export const keywords = {
     return array.length
   },
   [KEYWORDS.IF]: (args, env) => {
-    if (args.length > 3 || args.length < 2)
+    if (args.length !== 3)
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.IF
-        }), expected (or (= 3) (= 2)) but got ${args.length}\n\n(${
+        }), expected (= 3) but got ${args.length}\n\n(${
           KEYWORDS.IF
         } ${stringifyArgs(args)})`
       )
@@ -473,11 +488,7 @@ export const keywords = {
           KEYWORDS.IF
         } ${stringifyArgs(args)})`
       )
-    return condition
-      ? evaluate(args[1], env)
-      : args.length === 3
-      ? evaluate(args[2], env)
-      : FALSE
+    return condition ? evaluate(args[1], env) : evaluate(args[2], env)
   },
   [KEYWORDS.NOT]: (args, env) => {
     if (args.length !== 1)

package/src/keywords.js

@@ -41,7 +41,8 @@ export const KEYWORDS = {
   CALL_FUNCTION: 'apply',
   DEFINE_VARIABLE: 'let',
 
-  SET_ARRAY: 'alter!',
+  SET_ARRAY: 'set!',
+  POP_ARRAY: 'pop!',
   ERROR: 'throw'
 }
 

package/src/macros.js

@@ -362,6 +362,20 @@ export const deSuggarAst = (ast, scope) => {
                 }
                 deSuggarAst(exp, scope)
                 break
+              case KEYWORDS.IF:
+                {
+                  if (rest.length > 3 || rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        KEYWORDS.IF
+                      }), expected (or (= 3) (= 2)) but got ${rest.length} (${
+                        KEYWORDS.IF
+                      } ${stringifyArgs(rest)})`
+                    )
+                  if (rest.length === 2) exp.push([ATOM, FALSE])
+                }
+                deSuggarAst(exp[1], scope)
+                break
               case SUGGAR.REMAINDER_OF_DIVISION_1:
                 {
                   if (rest.length !== 2)