fez-lisp 1.0.7 → 1.0.9

package/package.json

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

package/src/compiler.js

@@ -17,12 +17,20 @@ while(typeof result==='function')result=result()
 return result
   }`,
   isNumber: `numberPredicate=(number)=>typeof number==='number'`,
-  isString: `stringPredicate=(string)=>typeof number==='string'`,
+  isString: `stringPredicate=(string)=>typeof string==='string'`,
   isLambda: `lambdaPredicate=(lambda)=>typeof lambda==='function'`,
   isArray: `arrayPredicate=(array)=>Array.isArray(array)`,
   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) {
@@ -46,9 +54,9 @@ return result
       case '${KEYWORDS.ANONYMOUS_FUNCTION}':
           return ()=>value
       case '${KEYWORDS.CHAR_CODE_TYPE}':
-        return String.fromCharCode(value)
-      case '${KEYWORDS.CHAR_TYPE}':
         return value.charCodeAt(0)
+      case '${KEYWORDS.CHAR_TYPE}':
+        return String.fromCharCode(value)
        default:
          return 0
       }
@@ -234,6 +242,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 +320,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

@@ -76,4 +76,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)})`)