try to use recursive-lambda instead of defined-lambda

Author: xieyuheng

TODO.md

@@ -1,7 +1,3 @@
-use `RecursiveLambda` instead of `DefinedLambda`
-`markAllRecursiveFunctions`
-`sameInCtx` -- use head on `DelayedApply`, but only for `RecursiveLambda`
-
 # lazy evaluation
 
 we still can bring back lazy evaluation by lazy + box,
@@ -18,6 +14,11 @@ maybe only way to understand a reduction strategy
 is to see a lot of reduction paths.
 we need to see why current strategy can handle `Y`.
 
+# recursive lambda
+
+use `RecursiveLambda` instead of `DefinedLambda` -- i tried, but it is to slow
+`sameInCtx` -- use head on `DelayedApply`, but only for `RecursiveLambda`
+
 # later
 
 `formatValue` -- use `let` to print closure

examples/tests/undefined-name.error.lisp.err

@@ -1,3 +1,3 @@
 [load] I find undefined name: g
   defining: f
-  body: (lambda (x) (g x))
+  to: : (lambda (x) (g x))

src/lang/exp/expIndirectFreeNames.ts

@@ -0,0 +1,31 @@
+import assert from "node:assert"
+import { setPop } from "../../utils/set/setPop.ts"
+import type { Mod } from "../mod/index.ts"
+import { modOwnDefs } from "../mod/index.ts"
+import type { Exp } from "./Exp.ts"
+import { expFreeNames } from "./expFreeNames.ts"
+
+export function expIndirectFreeNames(mod: Mod, exp: Exp): Set<string> {
+  const ownDefs = modOwnDefs(mod)
+  const remainingNames = expFreeNames(new Set(), exp)
+  const collectedNames = new Set<string>()
+
+  while (remainingNames.size > 0) {
+    const name = setPop(remainingNames)
+    if (collectedNames.has(name)) continue
+
+    collectedNames.add(name)
+
+    const def = ownDefs.get(name)
+    if (def === undefined) continue
+
+    assert(def.freeNames)
+    for (const freeName of def.freeNames) {
+      if (!collectedNames.has(freeName)) {
+        remainingNames.add(freeName)
+      }
+    }
+  }
+
+  return collectedNames
+}

src/lang/exp/index.ts

@@ -1,3 +1,4 @@
 export * from "./Bind.ts"
 export * from "./Exp.ts"
 export * from "./expFreeNames.ts"
+export * from "./expIndirectFreeNames.ts"

src/lang/load/load.ts

@@ -1,14 +1,11 @@
 import { ParsingError } from "@xieyuheng/x-data.js"
+import dedent from "dedent"
+import assert from "node:assert"
 import fs from "node:fs"
 import { expFreeNames } from "../exp/expFreeNames.ts"
+import { expIndirectFreeNames } from "../exp/index.ts"
 import { formatExp } from "../format/formatExp.ts"
-import {
-  createMod,
-  modFind,
-  modOwnDefs,
-  type Def,
-  type Mod,
-} from "../mod/index.ts"
+import { createMod, modFind, modOwnDefs, type Mod } from "../mod/index.ts"
 import { parseStmts } from "../parse/index.ts"
 import { globalLoadedMods } from "./globalLoadedMods.ts"
 import { handleDefine } from "./handleDefine.ts"
@@ -42,24 +39,34 @@ async function run(mod: Mod): Promise<void> {
   for (const stmt of mod.stmts) await handleDefine(mod, stmt)
   for (const stmt of mod.stmts) await handleImport(mod, stmt)
 
-  for (const def of modOwnDefs(mod).values()) postprocessDef(mod, def)
+  postprocess(mod)
 
   for (const stmt of mod.stmts) await handleEffect(mod, stmt)
 
   mod.isFinished = true
 }
 
-function postprocessDef(mod: Mod, def: Def): void {
-  def.freeNames = expFreeNames(new Set(), def.exp)
-  for (const name of def.freeNames) {
-    if (modFind(mod, name) === undefined) {
-      throw new Error(
-        [
-          `[load] I find undefined name: ${name}`,
-          `  defining: ${def.name}`,
-          `  body: ${formatExp(def.exp)}`,
-        ].join("\n"),
-      )
+function postprocess(mod: Mod): void {
+  for (const def of modOwnDefs(mod).values()) {
+    def.freeNames = expFreeNames(new Set(), def.exp)
+  }
+
+  for (const def of modOwnDefs(mod).values()) {
+    assert(def.freeNames)
+    for (const name of def.freeNames) {
+      if (!modFind(mod, name)) {
+        throw new Error(dedent`
+          [load] I find undefined name: ${name}
+            defining: ${def.name}
+            to: : ${formatExp(def.exp)}
+          `)
+      }
+    }
+  }
+
+  for (const def of modOwnDefs(mod).values()) {
+    if (expIndirectFreeNames(mod, def.exp).has(def.name)) {
+      def.isRecursive = true
     }
   }
 }

src/lang/mod/Mod.ts

@@ -10,6 +10,7 @@ export type Def = {
   exp: Exp
   freeNames?: Set<string>
   value?: Value
+  isRecursive?: boolean
 }
 
 export type Mod = {
@@ -42,7 +43,17 @@ export function modFindValue(mod: Mod, name: string): Value | undefined {
   if (def.value) return def.value
 
   const value = evaluate(def.mod, emptyEnv(), def.exp)
-  if (value.kind === "Lambda" && value.definedName === undefined) {
+
+  // TODO Uncomment the following,
+  // will only blaze recursive function,
+  // but it will be to slow for `equalInCtx`.
+  // I do not fully understand it yet.
+
+  if (
+    // def.isRecursive &&
+    value.kind === "Lambda" &&
+    value.definedName === undefined
+  ) {
     value.definedName = def.name
   }