fez-lisp 1.2.60 → 1.2.62

package/README.md

@@ -54,9 +54,9 @@ World
 ```
 
 ```lisp
-(let Fizz (string char:F char:i char:z char:z))
-(let Buzz (string char:B char:u char:z char:z))
-(let FizzBuzz (string Fizz Buzz))
+(let Fizz (array char:F char:i char:z char:z))
+(let Buzz (array char:B char:u char:z char:z))
+(let FizzBuzz (array Fizz Buzz))
 
 (let fizz-buzz (lambda n
     (cond
@@ -152,9 +152,9 @@ eval(
 import { fez } from 'fez-lisp'
 fez(
   `
-(let Fizz (string char:F char:i char:z char:z))
-(let Buzz (string char:B char:u char:z char:z))
-(let FizzBuzz (string Fizz Buzz))
+(let Fizz (array char:F char:i char:z char:z))
+(let Buzz (array char:B char:u char:z char:z))
+(let FizzBuzz (array Fizz Buzz))
 
 (let fizz-buzz (lambda n
     (cond

package/package.json

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

package/src/compiler.js

@@ -8,23 +8,14 @@ import {
   WORD,
   SUGGAR
 } from './keywords.js'
-import { leaf, isLeaf } from './parser.js'
-const deepRenameTco = (name, newName, tree) => {
+import { leaf, isLeaf, AST } from './parser.js'
+const deepRename = (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}`
-      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
+      // I can get rid of deep clone AST.parse(AST.stringify(ast))
       if (leaf[VALUE] === name) leaf[VALUE] = newName
-      deepRenameCache(name, newName, leaf)
+      deepRename(name, newName, leaf)
     }
 }
 const earMuffsToLodashes = (name) => name.replace(new RegExp(/\*/g), '_')
@@ -93,7 +84,7 @@ const Helpers = {
   __eq: '__eq=(a,b)=>+(a===b)',
   __lteq: '__lteq=(a,b)=>+(a<=b)',
   __lt: '__lt=(a,b)=>+(a<b)',
-  array: 'array=(x)=>[x]',
+  array: 'array=(...args)=>args',
   not: 'not=(a)=>+!a',
   and: `and=(...args)=>{
     let circuit;
@@ -192,7 +183,7 @@ const compile = (tree, Drill) => {
           const functionArgs = Arguments.at(-1).slice(1)
           const body = functionArgs.pop()
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
-          deepRenameTco(n, newName, body)
+          deepRename(n, `()=>${newName}`, body)
           const evaluatedBody = compile(body, FunctionDrill)
           const vars = FunctionDrill.Variables.size
             ? `var ${[...FunctionDrill.Variables].join(',')};`
@@ -210,7 +201,7 @@ const compile = (tree, Drill) => {
           Drill.Variables.add(name)
           const functionArgs = Arguments.at(-1).slice(1)
           const body = functionArgs.pop()
-          deepRenameCache(n, newName, body)
+          deepRename(n, newName, body)
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
           const evaluatedBody = compile(body, FunctionDrill)
           const vars = FunctionDrill.Variables.size
@@ -336,7 +327,7 @@ const compile = (tree, Drill) => {
 const HelpersEntries = new Map(Object.entries(Helpers))
 export const comp = (ast) => {
   const Drill = { Variables: new Set(), Helpers: new Set() }
-  const raw = ast
+  const raw = AST.parse(AST.stringify(ast)) // cloning for fn renames mutations
     .map((tree) => compile(tree, Drill))
     .filter((x) => x !== undefined)
     .join('\n')
@@ -355,5 +346,5 @@ export const comp = (ast) => {
     ? `var ${[...Drill.Variables].join(',')};`
     : ''
   const top = `${help}${vars}`
-  return { top, program }
+  return `${top}${program}`
 }

package/src/utils.js

@@ -239,7 +239,6 @@ export const dfs = (tree, callback) => {
   if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
   else callback(tree)
 }
-export const deepClone = (ast) => AST.parse(AST.stringify(ast))
 export const interpret = (ast, keywords) =>
   ast.reduce((_, x) => evaluate(x, keywords), 0)
 export const fez = (source, options = {}) => {
@@ -255,19 +254,13 @@ export const fez = (source, options = {}) => {
       const parsed = deSuggar(LISP.parse(code))
       const ast = [...treeShake(parsed, std), ...parsed]
       // if (options.check) typeCheck(ast)
-      if (options.compile) {
-        const js = Object.values(comp(deepClone(ast))).join('')
-        return js
-      }
+      if (options.compile) return comp(ast)
       return run(ast, env)
     } else if (Array.isArray(source)) {
       const ast = !options.mutation
         ? AST.parse(AST.stringify(source).replace(new RegExp(/!/g), 'ǃ'))
         : source
-      if (options.compile) {
-        const js = Object.values(comp(deepClone(ast))).join('')
-        return js
-      }
+      if (options.compile) return comp(ast)
       return run(ast, env)
     } else {
       throw new Error('Source has to be either a lisp source code or an AST')