fez-lisp 1.0.7 → 1.0.8

package/package.json

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

package/src/compiler.js

@@ -23,6 +23,14 @@ return result
   isAtom: `atomPredicate=(value)=>typeof value==='number'||typeof value==='string'`,
   error: `_error=(error)=>{ 
     throw new Error(error)
+}`,
+  set: `set=(array,index,value)=>{ 
+  array=[...array]
+  if (index < 0) {
+   const target = array.length + index
+   while (array.length !== target) array.pop()
+  } else array[index] = value; 
+  return array 
 }`,
   setArray: `setEffect=(array,index,value)=>{ 
     if (index < 0) {
@@ -210,6 +218,7 @@ const compile = (tree, Variables) => {
       case KEYWORDS.CONCATENATION:
         return '(' + parseArgs(Arguments, Variables, '+') + ');'
       case KEYWORDS.EQUAL:
+      case KEYWORDS.EQUALITY:
         return handleBoolean(`(${parseArgs(Arguments, Variables, '===')});`)
       case KEYWORDS.GREATHER_THAN_OR_EQUAL:
       case KEYWORDS.LESS_THAN_OR_EQUAL:
@@ -234,6 +243,9 @@ const compile = (tree, Variables) => {
             : `(${parseArgs(Arguments, Variables, token)});`
           : `(0);`
       case KEYWORDS.ADDITION:
+        return Arguments.length
+          ? `(${parseArgs(Arguments, Variables, token)});`
+          : `(0);`
       case KEYWORDS.BITWISE_AND:
       case KEYWORDS.BITWISE_OR:
       case KEYWORDS.BITWISE_XOR:
@@ -309,6 +321,8 @@ const compile = (tree, Variables) => {
       }
       case KEYWORDS.SERIALISE:
         return `_serialise(${compile(Arguments[0], Variables)});`
+      case KEYWORDS.SET_IMMUTABLE_ARRAY:
+        return `set(${parseArgs(Arguments, Variables)}));`
       case KEYWORDS.SET_ARRAY:
         return `setEffect(${parseArgs(Arguments, Variables)});`
       case KEYWORDS.NOT_COMPILED_BLOCK:

package/src/enums.js

@@ -54,6 +54,7 @@ export const KEYWORDS = {
   CONDITION: 'cond',
 
   NOT: 'not',
+  EQUALITY: 'eq',
   EQUAL: '=',
   LESS_THAN: '<',
   GREATHER_THAN: '>',
@@ -76,4 +77,5 @@ export const KEYWORDS = {
   SERIALISE: 'serialise',
 
   SET_ARRAY: 'set!',
+  SET_IMMUTABLE_ARRAY: 'set',
 }

package/src/interpreter.js

@@ -9,18 +9,18 @@ export const evaluate = (exp, env) => {
     case WORD: {
       const word = env[first[VALUE]]
       if (word == undefined)
-        throw new ReferenceError(`Undefined variable ${first[VALUE]}.`)
+        throw new ReferenceError(`Undefined variable ${first[VALUE]}`)
       return word
     }
     case APPLY:
       const apply = env[first[VALUE]]
       if (apply == undefined)
         throw new ReferenceError(
-          `Undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) ${first[VALUE]}.`
+          `Undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) ${first[VALUE]}`
         )
       if (typeof apply !== 'function')
         throw new TypeError(
-          `${first[VALUE]} is not a (${KEYWORDS.ANONYMOUS_FUNCTION}).`
+          `${first[VALUE]} is not a (${KEYWORDS.ANONYMOUS_FUNCTION})`
         )
       return apply(rest, env)
     case ATOM:

package/src/parser.js

@@ -46,7 +46,8 @@ export const parse = (source) => {
 export const stringify = (ast) => {
   if (ast == undefined) return '()'
   else if (typeof ast === 'object')
-    if (Array.isArray(ast)) return `(array ${ast.map(stringify).join(' ')})`
+    if (Array.isArray(ast))
+      return ast.length ? `(array ${ast.map(stringify).join(' ')})` : '()'
     else
       return `(array ${Object.entries(ast)
         .map(([key, value]) => `("${key}" ${stringify(value)})`)