fez-lisp 1.2.43 → 1.2.45

package/package.json

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

package/src/compiler.js

@@ -8,13 +8,22 @@ import {
   WORD
 } from './keywords.js'
 import { leaf, isLeaf } from './parser.js'
-const deepRename = (name, newName, tree) => {
+const deepRenameTco = (name, newName, tree) => {
   if (!isLeaf(tree))
     for (const leaf of tree) {
       // Figure out a non mutable solution so
       // I can get rid of deep copy
       if (leaf[VALUE] === name) leaf[VALUE] = `()=>${newName}`
-      deepRename(name, newName, leaf)
+      deepRenameTco(name, newName, leaf)
+    }
+}
+const deepRenameCache = (name, newName, tree) => {
+  if (!isLeaf(tree))
+    for (const leaf of tree) {
+      // Figure out a non mutable solution so
+      // I can get rid of deep copy
+      if (leaf[VALUE] === name) leaf[VALUE] = newName
+      deepRenameCache(name, newName, leaf)
     }
 }
 const earMuffsToLodashes = (name) => name.replace(new RegExp(/\*/g), '_')
@@ -109,7 +118,7 @@ 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=function(array,index,value){if(arguments.length===1){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([
@@ -166,16 +175,20 @@ const compile = (tree, Drill) => {
       }
       case KEYWORDS.DEFINE_VARIABLE: {
         const n = Arguments[0][VALUE]
-        if (n.split(':')[0] === KEYWORDS.RECURSION) {
+        const prefix = n.split(':')[0]
+        if (prefix === KEYWORDS.RECURSION) {
           const name = lispToJavaScriptVariableName(n)
-          const newName = `rec_${performance.now().toString().replace('.', 7)}`
+          const newName = `recursive_${performance
+            .now()
+            .toString()
+            .replace('.', 7)}`
           Drill.Variables.add(name)
           Drill.Variables.add(newName)
           Drill.Helpers.add('__tco')
           const functionArgs = Arguments.at(-1).slice(1)
           const body = functionArgs.pop()
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
-          deepRename(n, newName, body)
+          deepRenameTco(n, newName, body)
           const evaluatedBody = compile(body, FunctionDrill)
           const vars = FunctionDrill.Variables.size
             ? `var ${[...FunctionDrill.Variables].join(',')};`
@@ -186,6 +199,25 @@ const compile = (tree, Drill) => {
           )})=>{${vars}return ${evaluatedBody
             .toString()
             .trim()}}, ${newName})));`
+        } else if (prefix === KEYWORDS.CACHE) {
+          // memoization here
+          const name = lispToJavaScriptVariableName(n)
+          const newName = name.substring(KEYWORDS.CACHE.length + 1)
+          Drill.Variables.add(name)
+          const functionArgs = Arguments.at(-1).slice(1)
+          const body = functionArgs.pop()
+          deepRenameCache(n, newName, body)
+          const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
+          const evaluatedBody = compile(body, FunctionDrill)
+          const vars = FunctionDrill.Variables.size
+            ? `var ${[...FunctionDrill.Variables].join(',')};`
+            : ''
+          return `(${name}=function(){var __${newName}_map = new Map();var ${newName}=(function(${parseArgs(
+            functionArgs,
+            Drill
+          )}){${vars};var __key=[...arguments].join(',');if(__${newName}_map.has(__key)){return __${newName}_map.get(__key)}else{var __res = ${evaluatedBody
+            .toString()
+            .trim()};__${newName}_map.set(__key, __res);return __res}});return ${newName}(...arguments)});`
         } else {
           const name = lispToJavaScriptVariableName(n)
           Drill.Variables.add(name)
@@ -198,10 +230,6 @@ const compile = (tree, Drill) => {
       case KEYWORDS.IS_LAMBDA:
         Drill.Helpers.add('lambda_predicate')
         return `lambda_predicate(${compile(Arguments[0], Drill)});`
-      case KEYWORDS.NUMBER_TYPE:
-        return '0'
-      case KEYWORDS.BOOLEAN_TYPE:
-        return '1'
       case KEYWORDS.ARRAY_TYPE:
         return `[${parseArgs(Arguments, Drill)}];`
       case KEYWORDS.ARRAY_LENGTH:

package/src/interpreter.js

@@ -675,11 +675,11 @@ export const keywords = {
   //   return evaluate(inp, env)
   // },
   [KEYWORDS.SET_ARRAY]: (args, env) => {
-    if (args.length !== 2 && args.length !== 3)
+    if (args.length !== 1 && args.length !== 3)
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.SET_ARRAY
-        }) (or 2 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
+        }) (or 1 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
       )
     const array = evaluate(args[0], env)
     if (!Array.isArray(array))
@@ -688,31 +688,17 @@ export const keywords = {
           KEYWORDS.ARRAY_TYPE
         }) but got (${array}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
       )
-    const index = evaluate(args[1], env)
-    if (!Number.isInteger(index))
-      throw new TypeError(
-        `Second argument of (${KEYWORDS.SET_ARRAY}) must be an (${
-          KEYWORDS.NUMBER_TYPE
-        } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (index > array.length)
-      throw new RangeError(
-        `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
-          KEYWORDS.ARRAY_TYPE
-        }) bounds (index ${index} bounds ${array.length}) (${
-          KEYWORDS.SET_ARRAY
-        } ${stringifyArgs(args)})`
-      )
-    if (index < 0) {
-      if (args.length !== 2)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_ARRAY
-          }) (if (< index 0) then 2 required) (${
-            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 (${
+            KEYWORDS.NUMBER_TYPE
+          } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
         )
-      if (index * -1 > array.length)
+      if (index > array.length)
         throw new RangeError(
           `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
             KEYWORDS.ARRAY_TYPE
@@ -720,17 +706,6 @@ export const keywords = {
             KEYWORDS.SET_ARRAY
           } ${stringifyArgs(args)})`
         )
-      const target = array.length + index
-      while (array.length !== target) array.pop()
-    } else {
-      if (args.length !== 3)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_ARRAY
-          }) (if (>= index 0) then 3 required) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
-        )
       const value = evaluate(args[2], env)
       if (value == undefined)
         throw new RangeError(
@@ -819,4 +794,4 @@ export const keywords = {
       )
     throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   }
-}
+}

package/src/keywords.js

@@ -57,7 +57,9 @@ export const KEYWORDS = {
   NOT_EQUAL_2: '<>',
   UNLESS: 'unless',
   LIST_TYPE: 'list',
-  RECURSION: 'rec'
+
+  RECURSION: 'recursive',
+  CACHE: 'memoized'
 }
 
 export const TYPES = {

package/src/utils.js

@@ -102,6 +102,8 @@ export const isForbiddenVariableName = (name) => {
   switch (name) {
     case '_':
     case KEYWORDS.DEFINE_VARIABLE:
+    case KEYWORDS.RECURSION:
+    case KEYWORDS.CACHE:
       return true
     default:
       return !isNaN(name[0])
@@ -262,9 +264,8 @@ export const fez = (source, options = {}) => {
     }
   } catch (error) {
     // console.log(error)
-    const err = error.message
-      .replace("'[object Array]'", '(array)')
-      .replace('object', '(array)')
+    const err = error.message.replace("'[object Array]'", '(array)')
+    // .replace('object', '(array)')
     logError(err)
     if (options.throw) throw err
     return err