fez-lisp 1.4.0 → 1.4.1

package/package.json

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

package/src/compiler.js

@@ -116,7 +116,7 @@ const Helpers = {
   length: 'length=(arr)=>arr.length',
   __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')`,
+  lambda_predicate: `lambda_predicate=(fn)=>+(typeof fn==='function')`,
   set_effect: `set_effect=function(array,index,value){if(arguments.length===1){array.pop()}else{array[index] = value};return array}`
 }
 const semiColumnEdgeCases = new Set([

package/src/evaluator.js

@@ -9,11 +9,7 @@ import {
   WORD
 } from './keywords.js'
 import { isLeaf } from './parser.js'
-import { stringifyArgs } from './utils.js'
-export const DEFAULT_MAXIMUM_FUNCTION_CALLS = 262144
-export const MAXIMUM_FUNCTION_CALLS = process.env.FEZ_MAXIMUM_FUNCTION_CALLS
-  ? +process.env.FEZ_MAXIMUM_FUNCTION_CALLS
-  : DEFAULT_MAXIMUM_FUNCTION_CALLS
+import { callStack, stringifyArgs } from './utils.js'
 export const evaluate = (exp, env = keywords) => {
   const [first, ...rest] = isLeaf(exp) ? [exp] : exp
   if (first == undefined) return []
@@ -36,15 +32,8 @@ export const evaluate = (exp, env = keywords) => {
           `${value} is not a (${KEYWORDS.ANONYMOUS_FUNCTION})`
         )
       const isSpecial = SPECIAL_FORMS_SET.has(value)
-      if (!isSpecial) {
-        evaluate.count = (evaluate.count || 0) + 1
-        if (evaluate.count > MAXIMUM_FUNCTION_CALLS) {
-          evaluate.count = 0
-          throw new RangeError('Maximum function invocation limit exceeded')
-        }
-      }
       const result = apply(rest, env, value)
-      if (!isSpecial) evaluate.stack.pop()
+      if (!isSpecial) callStack.pop()
       return result
     }
     case ATOM:
@@ -55,4 +44,3 @@ export const evaluate = (exp, env = keywords) => {
       )
   }
 }
-evaluate.stack = [KEYWORDS.CALL_FUNCTION]

package/src/interpreter.js

@@ -9,7 +9,7 @@ import {
   RUNTIME_TYPES
 } from './keywords.js'
 import { evaluate } from './evaluator.js'
-import { isForbiddenVariableName, stringifyArgs } from './utils.js'
+import { callStack, isForbiddenVariableName, stringifyArgs } from './utils.js'
 import { LISP } from './parser.js'
 export const keywords = {
   [KEYWORDS.ADDITION]: (args, env) => {
@@ -697,7 +697,7 @@ export const keywords = {
           writable: true
         })
       }
-      if (name) evaluate.stack.push(name)
+      if (name) callStack.push(name)
       return evaluate(body, localEnv)
     }
   },
@@ -724,7 +724,9 @@ export const keywords = {
       throw new TypeError(
         `Last argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
           KEYWORDS.ANONYMOUS_FUNCTION
-        })\n\nat:\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
+        }) but got ${LISP.stringify(apply)}\n\nat:\n(${
+          KEYWORDS.CALL_FUNCTION
+        } ${stringifyArgs(args)})`
       )
 
     return apply(args.slice(0, -1), env)

package/src/parser.js

@@ -30,6 +30,8 @@ export const LISP = {
   },
   stringify: (array) => {
     if (array == undefined) return '()'
+    else if (typeof array === 'function') return '(lambda)'
+    else if (typeof array === 'boolean') return +array
     else if (typeof array === 'object')
       if (Array.isArray(array))
         return array.length
@@ -39,8 +41,6 @@ export const LISP = {
         return `(array ${array
           .map(([key, value]) => `("${key}" ${LISP.stringify(value)})`)
           .join(' ')})`
-    else if (typeof array === 'function') return '()'
-    else if (typeof array === 'boolean') return +array
     else return array
   },
   source: (ast) => {

package/src/utils.js

@@ -23,8 +23,6 @@ import { keywords } from './interpreter.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log('\x1b[32m', output, '\x1b[0m')
-// export const replaceEmptyArrays = (source) =>
-//   source
 export const removeNoCode = (source) =>
   source
     .replace(/;.+/g, '')
@@ -160,6 +158,7 @@ export const handleUnbalancedParens = (source) => {
 export const removeMutation = (source) => source.replace(new RegExp(/!/g), 'ǃ')
 const isDefinition = (x) =>
   x[TYPE] === APPLY && x[VALUE] === KEYWORDS.DEFINE_VARIABLE
+// [[, [, libs]]] is because std is wrapped in (apply (lambda (do ...)))
 const toDeps = ([[, [, libs]]]) =>
   libs.reduce(
     (a, x, i) => a.set(x.at(1)[VALUE], { value: x, index: i }),
@@ -266,38 +265,6 @@ export const fez = (source, options = {}) => {
     return err
   }
 }
-export const compress = (source) => {
-  let { result, occurance } = source.split('').reduce(
-    (acc, item) => {
-      if (item === ')') acc.occurance++
-      else {
-        if (acc.occurance < 3) {
-          acc.result += ')'.repeat(acc.occurance)
-          acc.occurance = 0
-        } else {
-          acc.result += '·' + acc.occurance
-          acc.occurance = 0
-        }
-        acc.result += item
-      }
-      return acc
-    },
-    { result: '', occurance: 0 }
-  )
-  if (occurance > 0) result += '·' + occurance
-  return result
-}
-export const decompress = (raw) => {
-  const suffix = [...new Set(raw.match(/·+?\d+/g))]
-  const runes = suffix.reduce(
-    (acc, m) => acc.split(m).join(')'.repeat(parseInt(m.substring(1)))),
-    raw
-  )
-  let result = ''
-  for (const tok of runes) result += tok
-  return result
-}
-// shake(LISP.parse(removeNoCode(source)), std)
 export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)
 export const tree = (source, std) =>
   std
@@ -340,7 +307,20 @@ export const parse = (source) =>
       std
     )
   )
+
+const identity = (name) => [
+  [0, 'let'],
+  [1, name],
+  [
+    [0, 'lambda'],
+    [1, 'x'],
+    [1, 'x']
+  ]
+]
+export const callStack = [KEYWORDS.CALL_FUNCTION]
 export const debug = (ast) => {
+  callStack.length = 0
+  callStack.push(KEYWORDS.CALL_FUNCTION)
   try {
     const debugEnv = {
       ...keywords,
@@ -467,24 +447,14 @@ export const debug = (ast) => {
     }
     evaluate(ast, debugEnv)
   } catch (error) {
-    if (
-      !error.message.includes('Maximum call stack size exceeded') &&
-      !error.message.includes('too much recursion') &&
-      error.message !== 'Maximum function invocation limit exceeded'
-    ) {
-      error.message += `\n\nscope:\n(${evaluate.stack.at(-1)})`
+    const isMaxCallStack =
+      error.message.includes('Maximum call stack size exceeded') ||
+      error.message.includes('too much recursion')
+    if (!isMaxCallStack) {
+      error.message += `\n\nscope:\n(${callStack.at(-1)})`
       throw error
     } else logError(error.message)
   }
-  const identity = (name) => [
-    [0, 'let'],
-    [1, name],
-    [
-      [0, 'lambda'],
-      [1, 'x'],
-      [1, 'x']
-    ]
-  ]
   const block = ast[1][1]
   const temp = block.shift()
   block.unshift(