Function eq

src/compute-engine/boxed-expression/compare.ts:136–258

(
  a: Expression,
  inputB: number | Expression
)

  // The lenient form — either side unbound ⇒ equal — was not merely "outside
  // the relation for raw expressions": a CANONICAL expression can CONTAIN raw
  // operands, because a lazy operator holds them un-canonicalized. So a
  // canonical `Map(…)` holding a raw `q` compared equal to canonical `Map(…)`s
  // from two different scopes that were themselves unequal — the transitivity
  // bridge sat inside the domain every dedup key uses.
  //
  // A caller that legitimately compares a TEMPLATE against a bound subject
  // asks for it explicitly (`sameSyntactic`) rather than relying on
  // unboundness as an implicit signal.
  return false;
}

/**
 * Is `def` the standard-library definition of `sym.symbol`?
 *
 * The engine's ROOT scope (the end of the parent chain) holds exactly the
 * standard library; every user declaration — including a top-level one —
 * lands in a child scope. Only reached when the two sides' definitions
 * already differ in identity, so the chain walk is off the hot path.
 */
function isLibraryBinding(
  sym: Expression & { symbol: string },
  def: BoxedBaseDefinition
): boolean {
  let scope = sym.engine.context?.lexicalScope;
  if (scope === undefined) return false;
  // Loose check: the chain terminates with `null` OR `undefined` depending on
  // how the root context was built.
  while (scope.parent != null) scope = scope.parent;
  const binding = scope.bindings.get(sym.symbol);
  if (binding === undefined) return false;
  // A scope binding is a tagged record; `baseDefinition` unwraps it, so
  // compare against both halves. (Inline — `isValueDef`/`isOperatorDef` live
  // in `utils.ts`, whose import would close the cycle `binders.ts` broke.)
  return (
    ('value' in binding && binding.value === def) ||
    ('operator' in binding && binding.operator === def)
  );
}

/**
 * Structural equality that compares symbols by NAME, ignoring bindings.
 *
 * For comparing a TEMPLATE against a subject: a rule pattern is parsed raw so
 * canonicalization cannot collapse its structure or mangle its wildcards,
 * which leaves its literal symbols unbound — the `\pi` of `\pi + a -> 2a`
 * must still match a canonical `π`. That is a question about syntax, not
 * about which binding a symbol denotes, so it gets its own entry point.
 */
export function sameSyntactic(a: Expression, b: Expression): boolean {
  return same(a, b, undefined, undefined, true);
}

/** What a node binds: name → its definition, or `null` when the binder names
 * the variable without owning its definition. See `boundVariableBindings`. */
type BinderMap = ReadonlyMap<string, BoxedValueDefinition | null>;

/**
 * Does an occurrence denote the enclosing binder?