fez-lisp 1.2.42 → 1.2.44

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.2.42",
+  "version": "1.2.44",
   "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), '_')
@@ -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,31 @@ 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(2)
+          Drill.Variables.add(name)
+          Drill.Variables.add(newName)
+          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(){const __${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 {
+          const __res = ${evaluatedBody.toString().trim()}
+          __${newName}_map.set(__key, __res)
+          return __res
+           }})
+          return ${newName}(...arguments)
+           });`
         } else {
           const name = lispToJavaScriptVariableName(n)
           Drill.Variables.add(name)

package/src/interpreter.js

@@ -1,7 +1,7 @@
 import { TYPE, VALUE, WORD, KEYWORDS, FALSE, TRUE, TYPES } from './keywords.js'
 import { evaluate } from './evaluator.js'
 import { isForbiddenVariableName, stringifyArgs } from './utils.js'
-const keywords = {
+export const keywords = {
   [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
     if (args.length < 2)
       throw new RangeError(
@@ -820,5 +820,3 @@ const keywords = {
     throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   }
 }
-
-export { keywords }

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
@@ -315,7 +316,7 @@ export const minify = (source) =>
     deSuggar(LISP.parse(replaceQuotes(replaceStrings(removeNoCode(source)))))
   )
 export const prep = (source) =>
-  deSuggar(LISP.parse(replaceQuotes(replaceStrings(removeNoCode(source)))))
+  deSuggar(LISP.parse(removeNoCode(replaceQuotes(replaceStrings(source)))))
 export const src = (source, deps) => {
   source = prep(source)
   return LISP.source([
@@ -336,6 +337,10 @@ export const ast = (source, deps) => {
     ...source
   ]
 }
+export const astWithStd = (source) => {
+  const parsed = prep(source)
+  return [...treeShake(parsed, std), ...parsed]
+}
 export const dependencies = (source, deps) => {
   source = prep(source)
   return shakedList(