eyeprolog 1.3.3 → 1.3.7

package/src/iso.js

@@ -1734,17 +1734,85 @@ function numberListBuiltin(kind) {
 const numberCharsBuiltin = numberListBuiltin('chars');
 const numberCodesBuiltin = numberListBuiltin('codes');
 
+class FindallListTerm {
+  constructor(items, offset = 0) {
+    this.type = COMPOUND;
+    this.name = '.';
+    this._items = items;
+    this._offset = offset;
+    this._compactLength = BigInt(items.length - offset);
+    this._args = null;
+  }
+  get arity() { return 2; }
+  get args() {
+    if (this._args == null) {
+      const next = this._offset + 1;
+      this._args = [
+        typeof this._items.get === 'function' ? this._items.get(this._offset) : this._items[this._offset],
+        next >= this._items.length ? emptyList() : new FindallListTerm(this._items, next),
+      ];
+    }
+    return this._args;
+  }
+}
+
+class FlatCompoundFindallItems {
+  constructor(template) {
+    this.name = template.name;
+    this.arity = template.arity;
+    this.columns = Array.from({ length: this.arity }, () => []);
+  }
+  get length() {
+    return this.arity === 0 ? 0 : this.columns[0].length;
+  }
+  push(template, env) {
+    const values = new Array(this.arity);
+    for (let i = 0; i < this.arity; i++) {
+      const value = deref(template.args[i], env);
+      if (value.type === VAR || value.type === COMPOUND) return false;
+      values[i] = value;
+    }
+    for (let i = 0; i < this.arity; i++) this.columns[i].push(values[i]);
+    return true;
+  }
+  get(index) {
+    return compound(this.name, this.columns.map((column) => column[index]));
+  }
+  materialize() {
+    const out = new Array(this.length);
+    for (let i = 0; i < out.length; i++) out[i] = this.get(i);
+    return out;
+  }
+}
+
+function findallListFromItems(items) {
+  return items.length === 0 ? emptyList() : new FindallListTerm(items);
+}
+
+function flatFindallTemplate(template) {
+  return template.type === COMPOUND && template.arity > 0 &&
+    template.args.every((arg) => arg.type !== COMPOUND)
+    ? new FlatCompoundFindallItems(template)
+    : null;
+}
+
 function* findallBuiltin({ solver, goal, env }) {
   const [template, innerGoal, bag] = goal.args;
   assertListOrPartial(bag, env);
   const collector = solver.cloneForInnerGoal(10000000);
-  const collected = [];
+  let compact = flatFindallTemplate(template);
+  let collected = compact == null ? [] : null;
   for (const answerEnv of collector.solve([callable(innerGoal, env)], env.clone(), 0)) {
+    if (compact != null && compact.push(template, answerEnv)) continue;
+    if (compact != null) {
+      collected = compact.materialize();
+      compact = null;
+    }
     collected.push(freshCopy(template, answerEnv));
   }
   solver.absorbStatsFrom(collector);
   const next = env.clone();
-  if (unify(bag, listFromItems(collected), next)) yield next;
+  if (unify(bag, findallListFromItems(compact ?? collected), next)) yield next;
 }
 
 function collectVariableNames(term, env, names = new Set()) {
@@ -1888,12 +1956,15 @@ function* countAllBuiltin({ solver, goal, env }) {
   }
 
   const invoked = callable(goal.args[0], env);
-  const child = solver.cloneForInnerGoal();
-  let count = 0n;
-  try {
-    for (const _ of child.solve([invoked], env.clone(), 0)) count++;
-  } finally {
-    solver.absorbStatsFrom(child);
+  let count = solver.fastCountGoal?.(invoked, env) ?? null;
+  if (count == null) {
+    const child = solver.cloneForInnerGoal();
+    count = 0n;
+    try {
+      for (const _ of child.solve([invoked], env.clone(), 0)) count++;
+    } finally {
+      solver.absorbStatsFrom(child);
+    }
   }
 
   const next = env.clone();
@@ -1970,11 +2041,33 @@ function* phraseBuiltin({ solver, goal, env }) {
     module: goal.module ?? grammarBody.module ?? 'user',
   });
   const finish = compound('=', [finalOutput, requestedOutput]);
-  const child = solver.cloneForInnerGoal();
+  // Recursive DCGs are automatically tabled in normal mode. Keep tables in a
+  // phrase-local scope keyed by the whole invocation. Repeatedly testing the
+  // same grammar/input (issue #48) reuses its completed table, while switching
+  // to a distinct input (issue #28) drops the previous invocation as one unit
+  // instead of retaining or individually evicting every recursive tail.
+  const phraseModule = goal.module ?? grammarBody.module ?? 'user';
+  const tableScopeSignature = solver.innerTableSignature(
+    [grammarBody, input, requestedOutput],
+    env,
+    `${phraseModule}:`,
+  );
+  const previousPhraseScope = solver.innerTableScopes.get('phrase');
+  const repeatedInvocation = previousPhraseScope?.signature === tableScopeSignature;
+  const child = solver.cloneForInnerGoal(solver.solutionLimit, {
+    tableScope: 'phrase',
+    tableScopeSignature,
+    // A new phrase input cannot benefit from tables retained for a different
+    // input. For structurally tail-consuming DCGs, execute it directly. If the
+    // same invocation repeats (the issue #48 pattern), normal tabling resumes
+    // and the compact phrase-local table is reused by subsequent repetitions.
+    skipListTailTabling: !repeatedInvocation,
+  });
   try {
     yield* child.solve([expanded, finish], env, 0);
   } finally {
     solver.absorbStatsFrom(child);
+    solver.trimInnerTableScope('phrase');
   }
 }
 const defaultErrorContext = atom('eyeprolog');
@@ -2032,11 +2125,28 @@ function prologErrorBall(error) {
   return freshCopy(term, new Env());
 }
 function* catchBuiltin({ solver, goal, env }) {
-  const child = solver.cloneForInnerGoal();
+  let child = null;
   try {
     // Corrigendum 2 removed catch/3's own callability errors so that errors
     // raised while converting/executing the protected goal are catchable.
-    yield* child.solve([callable(goal.args[0], env)], env.clone(), 0);
+    const invoked = callable(goal.args[0], env);
+    const direct = solver.registry.get(invoked.name, invoked.arity);
+    if (direct?.deterministic && (direct.shouldUse == null || direct.shouldUse({ solver, goal: invoked, env }))) {
+      // A deterministic builtin has no choice points whose lifetime must be
+      // isolated in a child solver. Running it directly avoids constructing a
+      // complete Solver for hot caught failures such as number_chars/2 syntax
+      // probes, while the cloned environment keeps catch/3's rollback boundary.
+      const iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
+      const result = iterator.next();
+      if (result.done) solver.stats.deterministic_builtin_failures++;
+      else {
+        solver.stats.deterministic_builtin_successes++;
+        yield result.value;
+      }
+      return;
+    }
+    child = solver.cloneForInnerGoal();
+    yield* child.solve([invoked], env.clone(), 0);
   } catch (error) {
     const ball = error instanceof ThrownTerm
       ? error.term
@@ -2046,9 +2156,15 @@ function* catchBuiltin({ solver, goal, env }) {
     if (ball == null) throw error;
     const recovered = env.clone();
     if (!unify(goal.args[1], ball, recovered)) throw error;
-    yield* solver.solve([callable(goal.args[2], recovered)], recovered, 0);
+    const recovery = callable(goal.args[2], recovered);
+    if (recovery.type === ATOM && (recovery.name === 'false' || recovery.name === 'fail')) return;
+    if (recovery.type === ATOM && recovery.name === 'true') {
+      yield recovered;
+      return;
+    }
+    yield* solver.solve([recovery], recovered, 0);
   } finally {
-    solver.absorbStatsFrom(child);
+    if (child != null) solver.absorbStatsFrom(child);
   }
 }
 function* throwBuiltin({ goal, env }) {
@@ -2071,7 +2187,25 @@ function* repeatBuiltin({ env }) {
   while (true) yield env;
 }
 function* negationBuiltin({ solver, goal, env }) {
-  for (const _ of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) return;
+  const invoked = callable(goal.args[0], env);
+  const direct = solver.registry.get(invoked.name, invoked.arity);
+  if (direct?.deterministic && (direct.shouldUse == null || direct.shouldUse({ solver, goal: invoked, env }))) {
+    const iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
+    const result = iterator.next();
+    if (result.done) {
+      solver.stats.deterministic_builtin_failures++;
+      yield env;
+    } else {
+      solver.stats.deterministic_builtin_successes++;
+    }
+    return;
+  }
+  const fastTruth = solver.fastGroundGoalTruth?.(invoked, env) ?? null;
+  if (fastTruth != null) {
+    if (!fastTruth) yield env;
+    return;
+  }
+  for (const _ of solver.cloneForInnerGoal(1).solve([invoked], env.clone(), 0)) return;
   yield env;
 }
 function* solveControlBranch(solver, goal, env) {

package/src/lib/iso_ext.pl

@@ -1,6 +1,7 @@
 /** Widely implemented extensions to the ISO Prolog core. */
 
 :- module(iso_ext, [
+    call_nth/2,
     countall/2,
     forall/2,
     succ/2,
@@ -9,6 +10,7 @@
     variant/2
 ]).
 
+:- meta_predicate(call_nth(0, '?')).
 :- meta_predicate(countall(0, '?')).
 :- meta_predicate(forall(0, 0)).
 :- meta_predicate(findall('?', 0, '?', '?')).
@@ -17,6 +19,8 @@
 % Trealla. These definitions use only EyeProlog's ISO profile; extensions that
 % require runtime cleanup, choice-point, alarm, or timeout hooks are omitted.
 
+call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
+
 countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 forall(Condition, Action) :-

package/src/lib/lists.pl

@@ -28,7 +28,6 @@
     min_list/2,
     max_list/2,
     list_to_set/2,
-    countall/2,
     set_nth0/4,
     take/3,
     drop/3,
@@ -45,7 +44,6 @@
 :- meta_predicate(foldl(3, '?', '?', '?')).
 :- meta_predicate(foldl(4, '?', '?', '?', '?')).
 :- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
-:- meta_predicate(countall(0, '?')).
 
 % Common pure-Prolog library predicates for EyeProlog.
 %
@@ -168,7 +166,6 @@ max_list([X|Xs], Max) :- lists__max_list(Xs, X, Max).
 
 list_to_set(List, Set) :- lists__list_to_set(List, [], Set).
 
-countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
 
 set_nth0(0, [_|Xs], X, [X|Xs]).
 set_nth0(N, [Y|Ys], X, [Y|Zs]) :-

package/src/program.js

@@ -166,6 +166,9 @@ export class Program {
       tabled: false,
       recursive: false,
       tableInputPositions: [],
+      tableAllVariants: false,
+      datalogLeastModel: false,
+      wfsDatalog: false,
       scalarFactsOnly: true,
       dynamic: this.dynamicPredicates.has(modulePredicateKey(module, name, arity)),
       negationStratum: null,
@@ -308,6 +311,7 @@ export class Program {
     const deps = groups.map(() => new Set());
     const cutDeps = groups.map(() => new Set());
     const negativeEdges = [];
+    const wfsNegativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
       for (const clause of group.clauses) {
@@ -337,12 +341,17 @@ export class Program {
             if (dep) {
               const dependencyIndex = indexByGroup.get(dep);
               deps[groupIndex].add(dependencyIndex);
-              if (dependency.negative) negativeEdges.push([groupIndex, dependencyIndex]);
+              if (dependency.negative) {
+                negativeEdges.push([groupIndex, dependencyIndex]);
+                if (dependency.wfs === true) wfsNegativeEdges.push([groupIndex, dependencyIndex]);
+              }
             }
           }
         }
       }
     }
+    const finiteDatalogCache = new Map();
+    const rangeRestrictedDatalogCache = new Map();
     for (const group of groups) {
       const start = indexByGroup.get(group);
       const standardLibraryModule = group.module !== 'user' &&
@@ -386,6 +395,36 @@ export class Program {
         !componentHasNegativeEdge(start, deps, negativeEdges) &&
         !group.cutRecursive &&
         !linearNumeric;
+      // Function-free positive recursive rules have a finite Herbrand base.
+      // They can safely use a shared most-general table, which avoids computing
+      // a separate recursive closure for every bound input (TC/SG/Wine style).
+      group.tableAllVariants = group.tabled && isFiniteDatalogGroup(this, group, finiteDatalogCache) &&
+        datalogDependencyClauseCount(this, group) >= 128;
+      // Large finite, range-restricted positive Datalog can be evaluated as a
+      // single indexed least model.  Keep tableAllVariants as the semantic
+      // fallback for finite programs whose answers may contain variables.
+      group.datalogLeastModel = group.tableAllVariants &&
+        isRangeRestrictedFiniteDatalogGroup(this, group, rangeRestrictedDatalogCache);
+    }
+
+    // Explicit tnot/1 opts finite, function-free Datalog into well-founded
+    // evaluation.  Keep ISO \+/1 and not/1 on their existing negation-as-failure
+    // path: WFS is an extension with different three-valued semantics and must
+    // not silently change ordinary Prolog programs.  A group is WFS-backed when
+    // its dependency cone reaches an SCC containing an edge introduced by
+    // tnot/1 and the whole cone is range-restricted finite Datalog.
+    const wfsCycleNodes = new Set();
+    for (const [from, to] of wfsNegativeEdges) {
+      if (!reachableIndexes(to, deps).has(from)) continue;
+      wfsCycleNodes.add(from);
+      wfsCycleNodes.add(to);
+    }
+    const finiteWfsCache = new Map();
+    for (const group of groups) {
+      const start = indexByGroup.get(group);
+      const reachable = reachableIndexes(start, deps);
+      const reachesWfsCycle = [...wfsCycleNodes].some((index) => reachable.has(index));
+      group.wfsDatalog = reachesWfsCycle && isFiniteWfsDatalogGroup(this, group, finiteWfsCache);
     }
   }
 
@@ -1253,6 +1292,185 @@ function reachableIndexes(start, deps) {
   return seen;
 }
 
+
+function isFiniteDatalogArgument(term) {
+  return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';
+}
+
+function datalogDependencyClauseCount(program, group, seen = new Set()) {
+  if (seen.has(group)) return 0;
+  seen.add(group);
+  let count = group.clauses.length;
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      if (clause.bodyName != null) {
+        const target = program.findGroup(clause.bodyName, 2, group.module);
+        if (target) count += datalogDependencyClauseCount(program, target, seen);
+      }
+      continue;
+    }
+    for (const goal of clause.body) {
+      if (goal.type !== COMPOUND && goal.type !== ATOM) continue;
+      const target = program.findGroup(goal.name, goal.arity, goal.module ?? group.module);
+      if (target) count += datalogDependencyClauseCount(program, target, seen);
+    }
+  }
+  return count;
+}
+
+function isFiniteDatalogGroup(program, group, cache = new Map(), visiting = new Set()) {
+  const cached = cache.get(group);
+  if (cached != null) return cached;
+  if (visiting.has(group)) return true;
+  visiting.add(group);
+  let finite = true;
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      if (clause.bodyName != null) {
+        const target = program.findGroup(clause.bodyName, 2, group.module);
+        if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+      }
+      continue;
+    }
+    if (clause.head.type === COMPOUND && !clause.head.args.every(isFiniteDatalogArgument)) { finite = false; break; }
+    if (clause.head.type !== COMPOUND && clause.head.type !== ATOM) { finite = false; break; }
+    for (const goal of clause.body) {
+      if (goal.type !== COMPOUND && goal.type !== ATOM) { finite = false; break; }
+      if (goal.type === COMPOUND && !goal.args.every(isFiniteDatalogArgument)) { finite = false; break; }
+      // Walk the whole positive dependency cone.  Requiring every reachable
+      // predicate to be source-defined and flat excludes builtins/generators
+      // that could manufacture an unbounded stream of fresh terms.
+      const target = program.findGroup(goal.name, goal.arity, goal.module ?? group.module);
+      if (!target || !isFiniteDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+    }
+    if (!finite) break;
+  }
+  visiting.delete(group);
+  cache.set(group, finite);
+  return finite;
+}
+
+
+function isRangeRestrictedFiniteDatalogGroup(program, group, cache = new Map(), visiting = new Set()) {
+  const cached = cache.get(group);
+  if (cached != null) return cached;
+  if (visiting.has(group)) return true;
+  visiting.add(group);
+  let finite = true;
+
+  for (const clause of group.clauses) {
+    const head = clause.head;
+    if ((head.type !== COMPOUND && head.type !== ATOM) ||
+        (head.type === COMPOUND && !head.args.every(isFiniteDatalogArgument))) {
+      finite = false;
+      break;
+    }
+
+    const headVariables = new Set();
+    const positiveVariables = new Set();
+    collectVariables(head, headVariables);
+    for (const goal of clause.body) {
+      if ((goal.type !== COMPOUND && goal.type !== ATOM) ||
+          (goal.type === COMPOUND && !goal.args.every(isFiniteDatalogArgument))) {
+        finite = false;
+        break;
+      }
+      collectVariables(goal, positiveVariables);
+      const target = program.findGroup(goal.name, goal.arity, goal.module ?? group.module);
+      if (!target || !isRangeRestrictedFiniteDatalogGroup(program, target, cache, visiting)) {
+        finite = false;
+        break;
+      }
+    }
+    if (!finite) break;
+    for (const name of headVariables) {
+      if (!positiveVariables.has(name)) {
+        // Ground facts have no head variables and pass naturally. A variable
+        // fact or a rule with an unbound head variable needs ordinary Prolog
+        // table semantics rather than finite relational materialization.
+        finite = false;
+        break;
+      }
+    }
+    if (!finite) break;
+  }
+
+  visiting.delete(group);
+  cache.set(group, finite);
+  return finite;
+}
+
+
+function isFiniteWfsDatalogGroup(program, group, cache = new Map(), visiting = new Set()) {
+  const cached = cache.get(group);
+  if (cached != null) return cached;
+  if (visiting.has(group)) return true;
+  visiting.add(group);
+  let finite = true;
+
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      if (clause.bodyName != null) {
+        const target = program.findGroup(clause.bodyName, 2, group.module);
+        if (!target || !isFiniteWfsDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+      }
+      continue;
+    }
+    if ((clause.head.type !== COMPOUND && clause.head.type !== ATOM) ||
+        (clause.head.type === COMPOUND && !clause.head.args.every(isFiniteDatalogArgument))) {
+      finite = false;
+      break;
+    }
+
+    const positiveVariables = new Set();
+    const requiredVariables = new Set();
+    collectVariables(clause.head, requiredVariables);
+    for (const goal of clause.body) {
+      if (goal.type !== COMPOUND && goal.type !== ATOM) { finite = false; break; }
+      if (goal.type === COMPOUND && goal.name === 'tnot' && goal.arity === 1) {
+        const inner = goal.args[0];
+        if ((inner.type !== COMPOUND && inner.type !== ATOM) ||
+            (inner.type === COMPOUND && !inner.args.every(isFiniteDatalogArgument))) {
+          finite = false;
+          break;
+        }
+        collectVariables(inner, requiredVariables);
+        const target = program.findGroup(inner.name, inner.arity, inner.module ?? group.module);
+        if (!target || !isFiniteWfsDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+        continue;
+      }
+      // WFS is explicit. Ordinary \+/1 and not/1 retain NAF and therefore
+      // disqualify this component from the WFS evaluator.
+      if (goal.type === COMPOUND && (goal.name === '\\+' || goal.name === 'not')) {
+        finite = false;
+        break;
+      }
+      if (goal.type === COMPOUND && !goal.args.every(isFiniteDatalogArgument)) { finite = false; break; }
+      collectVariables(goal, positiveVariables);
+      const target = program.findGroup(goal.name, goal.arity, goal.module ?? group.module);
+      if (!target || !isFiniteWfsDatalogGroup(program, target, cache, visiting)) { finite = false; break; }
+    }
+    if (!finite) break;
+    for (const name of requiredVariables) {
+      if (!positiveVariables.has(name)) { finite = false; break; }
+    }
+    if (!finite) break;
+  }
+
+  visiting.delete(group);
+  cache.set(group, finite);
+  return finite;
+}
+
+function collectVariables(term, output) {
+  if (!term) return;
+  if (term.type === VAR) {
+    output.add(term.name);
+    return;
+  }
+  for (const arg of term.args ?? []) collectVariables(arg, output);
+}
+
 function inferStructuralInputPositions(group) {
   let firstPatternedPosition = -1;
   let firstLinkedInputPosition = -1;
@@ -1304,14 +1522,31 @@ function hasStrictListTailRecursion(group) {
   let foundRecursiveCall = false;
   for (const clause of group.clauses) {
     if (isCompactBinaryClause(clause)) return false;
-    for (const goal of clause.body) {
+    for (let goalIndex = 0; goalIndex < clause.body.length; goalIndex++) {
+      const goal = clause.body[goalIndex];
       if (goal.type !== COMPOUND || goal.name !== group.name || goal.arity !== group.arity) continue;
       foundRecursiveCall = true;
       const decreases = goal.args.some((argument, index) => {
         const head = clause.head.args[index];
-        return head?.type === COMPOUND && head.name === '.' && head.arity === 2 &&
-          head.args[1]?.type === VAR && argument?.type === VAR &&
-          head.args[1].name === argument.name;
+        if (head?.type === COMPOUND && head.name === '.' && head.arity === 2 &&
+            head.args[1]?.type === VAR && argument?.type === VAR &&
+            head.args[1].name === argument.name) return true;
+        // DCG expansion represents [_], nt as Input = [_|Tail], nt(Tail,...).
+        // Treat that normalized prefix unification as the same strict list-tail
+        // decrease so phrase/2-3 can choose a non-tabled fast path for new
+        // inputs while retaining ordinary tabling for repeated invocations.
+        if (head?.type !== VAR || argument?.type !== VAR) return false;
+        for (let prefixIndex = 0; prefixIndex < goalIndex; prefixIndex++) {
+          const prefix = clause.body[prefixIndex];
+          if (prefix?.type !== COMPOUND || prefix.name !== '=' || prefix.arity !== 2) continue;
+          for (const [left, right] of [[prefix.args[0], prefix.args[1]], [prefix.args[1], prefix.args[0]]]) {
+            if (left?.type !== VAR || left.name !== head.name ||
+                right?.type !== COMPOUND || right.name !== '.' || right.arity !== 2 ||
+                right.args[1]?.type !== VAR) continue;
+            if (right.args[1].name === argument.name) return true;
+          }
+        }
+        return false;
       });
       if (!decreases) return false;
     }
@@ -1377,7 +1612,7 @@ function directGoalDependencyKey(goal) {
   if (goal.type === ATOM) return `${goal.name}/0`;
   if (goal.type !== COMPOUND) return null;
   if (goal.name === ',' && goal.arity === 2) return null;
-  if ((goal.name === '\\+' || goal.name === 'not') && goal.arity === 1) return null;
+  if ((goal.name === '\\+' || goal.name === 'not' || goal.name === 'tnot') && goal.arity === 1) return null;
   if (goal.name === 'once' && goal.arity === 1) return null;
   if (goal.name === 'forall' && goal.arity === 2) return null;
   if ((goal.name === 'findall' || goal.name === 'sumall') && goal.arity === 3) return null;
@@ -1386,43 +1621,46 @@ function directGoalDependencyKey(goal) {
   return `${goal.name}/${goal.arity}`;
 }
 
-function collectGoalDependencies(goal, negated, traverseConditionals = false) {
-  if (goal.type === ATOM) return [{ key: `${goal.name}/0`, name: goal.name, arity: 0, module: goal.module, negative: negated }];
+function collectGoalDependencies(goal, negated, traverseConditionals = false, wfs = false) {
+  if (goal.type === ATOM) return [{ key: `${goal.name}/0`, name: goal.name, arity: 0, module: goal.module, negative: negated, wfs }];
   if (goal.type !== COMPOUND) return [];
   if (goal.name === ',' && goal.arity === 2) {
     return [
-      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals),
-      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals),
+      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals, wfs),
+      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals, wfs),
     ];
   }
   if (traverseConditionals && (goal.name === ';' || goal.name === '->') && goal.arity === 2) {
     return [
-      ...collectGoalDependencies(goal.args[0], negated, true),
-      ...collectGoalDependencies(goal.args[1], negated, true),
+      ...collectGoalDependencies(goal.args[0], negated, true, wfs),
+      ...collectGoalDependencies(goal.args[1], negated, true, wfs),
     ];
   }
   if ((goal.name === '\\+' || goal.name === 'not') && goal.arity === 1) {
-    return collectGoalDependencies(goal.args[0], !negated, traverseConditionals);
+    return collectGoalDependencies(goal.args[0], !negated, traverseConditionals, wfs);
+  }
+  if (goal.name === 'tnot' && goal.arity === 1) {
+    return collectGoalDependencies(goal.args[0], !negated, traverseConditionals, true);
   }
   if (goal.name === 'once' && goal.arity === 1) {
-    return collectGoalDependencies(goal.args[0], negated, traverseConditionals);
+    return collectGoalDependencies(goal.args[0], negated, traverseConditionals, wfs);
   }
   if (goal.name === 'forall' && goal.arity === 2) {
     return [
-      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals),
-      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals),
+      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals, wfs),
+      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals, wfs),
     ];
   }
   if ((goal.name === 'findall' || goal.name === 'sumall') && goal.arity === 3) {
-    return collectGoalDependencies(goal.args[1], negated, traverseConditionals);
+    return collectGoalDependencies(goal.args[1], negated, traverseConditionals, wfs);
   }
   if (goal.name === 'countall' && goal.arity === 2) {
-    return collectGoalDependencies(goal.args[0], negated, traverseConditionals);
+    return collectGoalDependencies(goal.args[0], negated, traverseConditionals, wfs);
   }
   if ((goal.name === 'aggregate_min' || goal.name === 'aggregate_max') && goal.arity === 5) {
-    return collectGoalDependencies(goal.args[2], negated, traverseConditionals);
+    return collectGoalDependencies(goal.args[2], negated, traverseConditionals, wfs);
   }
-  return [{ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module, negative: negated }];
+  return [{ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module, negative: negated, wfs }];
 }
 
 function stronglyConnectedComponents(adjacency) {