fez-lisp 1.0.38 → 1.0.39

package/README.md

@@ -171,7 +171,7 @@ console.log(
 Pass tree source as text:
 
 ```js
-import { fez, parse } from '../index.js'
+import { fez } from '../index.js'
 const source = `(|> 
   (array 1 2 3 4)
   (math:permutations)

package/index.js

@@ -1,8 +1,8 @@
 import { evaluate } from './src/interpreter.js'
-import { parse, stringify, AST } from './src/parser.js'
+import { LISP, AST } from './src/parser.js'
 import { fez, tree } from './src/utils.js'
 import std from './lib/baked/std.js'
 import { keywords } from './src/tokeniser.js'
 import { WORD, APPLY, ATOM, VALUE, TYPE } from './src/enums.js'
 const types = { WORD, APPLY, ATOM, VALUE, TYPE }
-export { fez, parse, stringify, keywords, evaluate, std, types, tree, AST }
+export { fez, keywords, evaluate, std, types, tree, LISP, AST }

package/package.json

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

package/src/formatter.js

@@ -1,5 +1,5 @@
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './enums.js'
-import { isLeaf, parse } from './parser.js'
+import { isLeaf, LISP } from './parser.js'
 import { removeNoCode } from './utils.js'
 const tops = []
 const indent = (level) => ' '.repeat(level)
@@ -70,7 +70,7 @@ export const formatWithPreservedComments = (source) => {
     )
     .join('\n')
 
-  return format(parse(removeNoCode(value)))
+  return format(LISP.parse(removeNoCode(value)))
     .split('\n')
     .map((x) => {
       if (x.includes(commentIdentifier)) {

package/src/parser.js

@@ -2,55 +2,57 @@ import { APPLY, ATOM, WORD } from './enums.js'
 import { escape } from './utils.js'
 export const leaf = (type, value) => [type, value]
 export const isLeaf = ([car]) => car === APPLY || car === ATOM || car === WORD
-export const parse = (source) => {
-  const tree = []
-  let head = tree,
-    stack = [tree],
-    acc = ''
-  for (let i = 0; i < source.length; ++i) {
-    const cursor = source[i]
-    if (cursor === '"') {
-      acc += '"'
-      ++i
-      while (source[i] !== '"') {
-        if (source[i] === '\\') acc += escape(source[++i])
-        else acc += source[i]
+export const LISP = {
+  parse: (source) => {
+    const tree = []
+    let head = tree,
+      stack = [tree],
+      acc = ''
+    for (let i = 0; i < source.length; ++i) {
+      const cursor = source[i]
+      if (cursor === '"') {
+        acc += '"'
         ++i
+        while (source[i] !== '"') {
+          if (source[i] === '\\') acc += escape(source[++i])
+          else acc += source[i]
+          ++i
+        }
       }
+      if (cursor === '(') {
+        head.push([])
+        stack.push(head)
+        head = head.at(-1)
+      } else if (cursor === ')' || cursor === ' ') {
+        let token = acc
+        acc = ''
+        if (token) {
+          if (!head.length) head.push(leaf(APPLY, token))
+          else if (token.match(/^"([^"]*)"/))
+            head.push(leaf(ATOM, token.substring(1, token.length - 1)))
+          else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
+            head.push(leaf(ATOM, Number(token)))
+          else head.push(leaf(WORD, token))
+        }
+        if (cursor === ')') head = stack.pop()
+      } else acc += cursor
     }
-    if (cursor === '(') {
-      head.push([])
-      stack.push(head)
-      head = head.at(-1)
-    } else if (cursor === ')' || cursor === ' ') {
-      let token = acc
-      acc = ''
-      if (token) {
-        if (!head.length) head.push(leaf(APPLY, token))
-        else if (token.match(/^"([^"]*)"/))
-          head.push(leaf(ATOM, token.substring(1, token.length - 1)))
-        else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
-          head.push(leaf(ATOM, Number(token)))
-        else head.push(leaf(WORD, token))
-      }
-      if (cursor === ')') head = stack.pop()
-    } else acc += cursor
+    return tree
+  },
+  stringify: (ast) => {
+    if (ast == undefined) return '()'
+    else if (typeof ast === 'object')
+      if (Array.isArray(ast))
+        return ast.length ? `(array ${ast.map(stringify).join(' ')})` : '()'
+      else
+        return `(array ${ast
+          .map(([key, value]) => `("${key}" ${stringify(value)})`)
+          .join(' ')})`
+    else if (typeof ast === 'string') return `"${ast}"`
+    else if (typeof ast === 'function') return '()'
+    else if (typeof ast === 'boolean') return +ast
+    else return ast
   }
-  return tree
-}
-export const stringify = (ast) => {
-  if (ast == undefined) return '()'
-  else if (typeof ast === 'object')
-    if (Array.isArray(ast))
-      return ast.length ? `(array ${ast.map(stringify).join(' ')})` : '()'
-    else
-      return `(array ${ast
-        .map(([key, value]) => `("${key}" ${stringify(value)})`)
-        .join(' ')})`
-  else if (typeof ast === 'string') return `"${ast}"`
-  else if (typeof ast === 'function') return '()'
-  else if (typeof ast === 'boolean') return +ast
-  else return ast
 }
 export const AST = {
   parse: (source) => {

package/src/tokeniser.js

@@ -1,7 +1,7 @@
 import std from '../lib/baked/std.js'
 import { TYPE, VALUE, WORD, KEYWORDS, APPLY } from './enums.js'
 import { evaluate, isAtom } from './interpreter.js'
-import { stringify } from './parser.js'
+import { LISP } from './parser.js'
 import {
   isEqual,
   isEqualTypes,
@@ -990,14 +990,16 @@ const keywords = {
           ? console.log(
               '\x1b[31m',
               `${describe} Failed:\n`,
-              `${rest[0]} => ${stringify(rest[1])} != ${stringify(rest[2])}`,
+              `${rest[0]} => ${LISP.stringify(rest[1])} != ${LISP.stringify(
+                rest[2]
+              )}`,
               '\n',
               '\x1b[0m'
             )
           : console.log(
               '\x1b[32m',
               `${describe} Passed:\n`,
-              `${rest[0]} => ${stringify(rest[1])}`,
+              `${rest[0]} => ${LISP.stringify(rest[1])}`,
               '\n',
               '\x1b[0m'
             )
@@ -1017,7 +1019,7 @@ const keywords = {
         `Invalid number of arguments for (${KEYWORDS.SERIALISE})`
       )
     const data = evaluate(args[0], env)
-    return stringify(data)
+    return LISP.stringify(data)
   },
   [KEYWORDS.SET_ARRAY]: (args, env) => {
     if (args.length !== 2 && args.length !== 3)

package/src/utils.js

@@ -2,7 +2,7 @@ import std from '../lib/baked/std.js'
 import { comp } from './compiler.js'
 import { APPLY, KEYWORDS, TYPE, VALUE, WORD } from './enums.js'
 import { run } from './interpreter.js'
-import { AST, isLeaf, parse } from './parser.js'
+import { AST, isLeaf, LISP } from './parser.js'
 export const logError = (error) => console.log('\x1b[31m', error, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
 export const removeNoCode = (source) =>
@@ -142,21 +142,6 @@ export const treeShake = (ast, libs) => {
   // Filter out libraries that are not in the visited set
   return libs.filter((x) => visited.has(x.at(1)[VALUE]))
 }
-
-export const runFromCompiled = (source) => {
-  const tree = parse(
-    handleUnbalancedQuotes(handleUnbalancedParens(removeNoCode(source)))
-  )
-  const compiled = comp(tree)
-  const JavaScript = `${compiled.top}${compiled.program}`
-  return eval(JavaScript)
-}
-export const runFromInterpreted = (source, env = {}) => {
-  const tree = parse(
-    handleUnbalancedQuotes(handleUnbalancedParens(removeNoCode(source)))
-  )
-  run(tree, env)
-}
 export const dfs = (tree, callback) => {
   if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
   else callback(tree)
@@ -174,7 +159,7 @@ export const fez = (source, options = {}) => {
       else code = removeNoCode(source)
       if (!options.mutation) code = removeMutation(code)
       if (!code.length && options.throw) throw new Error('Nothing to parse!')
-      const parsed = parse(code)
+      const parsed = LISP.parse(code)
       if (parsed.length === 0 && options.throw)
         throw new Error(
           'Top level expressions need to be wrapped in a (do) block'
@@ -292,10 +277,12 @@ export const decompress = (raw) => {
   for (const tok of runes) result += tok
   return result
 }
-// shake(parse(removeNoCode(source)), std)
+// shake(LISP.parse(removeNoCode(source)), std)
 export const shake = (parsed, std) => [...treeShake(parsed, std), ...parsed]
 export const tree = (source, std) =>
-  std ? shake(parse(removeNoCode(source)), std) : parse(removeNoCode(source))
+  std
+    ? shake(LISP.parse(removeNoCode(source)), std)
+    : LISP.parse(removeNoCode(source))
 export const lispToJavaScriptVariableName = (name) =>
   toCamelCase(
     arrowFromTo(