fez-lisp 1.1.14 → 1.1.15

package/index.js

@@ -16,6 +16,7 @@ export {
   src,
   js,
   prep,
+  dependencies,
   LISP,
   AST
 }

package/package.json

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

package/src/utils.js

@@ -133,70 +133,68 @@ export const handleUnbalancedQuotes = (source) => {
   return source
 }
 export const removeMutation = (source) => source.replace(new RegExp(/!/g), 'ǃ')
-export const treeShake = (ast, libs) => {
-  const deps = libs.reduce((a, x) => a.set(x.at(1)[VALUE], x), new Map())
-  const visited = new Set()
-  const dfs = (tree, ignore = new Set()) => {
-    const type = tree[TYPE]
-    const value = tree[VALUE]
-    if (!isLeaf(tree)) {
-      const [car, ...rest] = tree
-      if (car == undefined) return
+const isDefinition = (x) =>
+  x[TYPE] === APPLY &&
+  (x[VALUE] === KEYWORDS.DEFINE_VARIABLE ||
+    x[VALUE] === KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION)
+const toDeps = (libs) =>
+  libs.reduce(
+    (a, x, i) => a.set(x.at(1)[VALUE], { value: x, index: i }),
+    new Map()
+  )
+const deepShake = (tree, deps, visited = new Set(), ignored = new Set()) => {
+  const type = tree[TYPE]
+  const value = tree[VALUE]
+  if (!isLeaf(tree)) {
+    const [car, ...rest] = tree
+    if (car == undefined) return
+    if (isDefinition(car)) {
       if (
-        car[TYPE] === APPLY &&
-        (car[VALUE] === KEYWORDS.DEFINE_VARIABLE ||
-          car[VALUE] === KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION)
+        !isLeaf(rest.at(-1)) &&
+        rest
+          .at(-1)
+          .some(
+            (x) => x[TYPE] === APPLY && x[VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+          )
       ) {
-        if (
-          !isLeaf(rest.at(-1)) &&
-          rest
-            .at(-1)
-            .some(
-              (x) =>
-                x[TYPE] === APPLY && x[VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
-            )
-        ) {
-          const args = rest
-            .at(-1)
-            .filter(
-              (x) =>
-                !(
-                  x[TYPE] === APPLY &&
-                  (x[VALUE] === KEYWORDS.ANONYMOUS_FUNCTION ||
-                    x[VALUE] === KEYWORDS.IMMUTABLE_FUNCTION)
-                )
-            )
-          const body = args.pop()
-          const params = new Set(args.map((x) => x[VALUE]))
-          dfs(body, params)
-        } else rest.forEach((x) => dfs(x, ignore))
-      } else tree.forEach((x) => dfs(x, ignore))
-    } else if (
-      (type === APPLY || type === WORD) &&
-      deps.has(value) &&
-      !visited.has(value) &&
-      !ignore.has(value)
-    ) {
-      visited.add(value)
-      // Recursively explore the dependencies of the current node
-      dfs(deps.get(value), ignore)
-    }
+        const args = rest.at(-1).filter((x) => !isDefinition(x))
+        const body = args.pop()
+        const params = new Set(args.map((x) => x[VALUE]))
+        deepShake(body, deps, visited, params)
+      } else rest.forEach((x) => deepShake(x, deps, visited, ignored))
+    } else tree.forEach((x) => deepShake(x, deps, visited, ignored))
+  } else if (
+    (type === APPLY || type === WORD) &&
+    deps.has(value) &&
+    !visited.has(value) &&
+    !ignored.has(value)
+  ) {
+    visited.add(value)
+    deepShake(deps.get(value).value, deps, visited, ignored)
   }
-  dfs(
-    ast,
-    new Set(
-      ast
-        .filter(
-          ([x]) =>
-            x[TYPE] === APPLY &&
-            (x[VALUE] === KEYWORDS.DEFINE_VARIABLE ||
-              x[VALUE] === KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION)
-        )
-        .map(([_, x]) => x[VALUE])
-    )
-  )
-  // Filter out libraries that are not in the visited set
-  return [...visited].reverse().map((x) => deps.get(x))
+}
+const extractDeps = (visited, deps) =>
+  [...visited]
+    .map((x) => deps.get(x))
+    .sort((a, b) => a.index - b.index)
+    .map((x) => x.value)
+const toIgnore = (ast) =>
+  ast.filter(([x]) => isDefinition(x)).map(([_, x]) => x[VALUE])
+export const treeShake = (ast, libs) => {
+  const deps = toDeps(libs)
+  const visited = new Set()
+  const ignored = new Set(toIgnore(ast))
+  deepShake(ast, deps, visited, ignored)
+  return extractDeps(visited, deps)
+}
+export const shakedList = (ast, libs) => {
+  const deps = toDeps(libs)
+  const visited = new Set()
+  const ignored = new Set(toIgnore(ast))
+  deepShake(ast, deps, visited, ignored)
+  const out = []
+  for (const [key] of deps) if (visited.has(key)) out.push(key)
+  return out
 }
 export const dfs = (tree, callback) => {
   if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
@@ -323,6 +321,13 @@ export const ast = (source, deps) => {
     ...source
   ]
 }
+export const dependencies = (source, deps) => {
+  source = prep(source)
+  return shakedList(
+    source,
+    deps.reduce((a, b) => a.concat(b), [])
+  )
+}
 export const js = (source, deps) => {
   source = prep(source)
   const { top, program } = comp([