Function replace

src/compute-engine/boxed-expression/rules.ts:1249–1416

(
  expr: Expression,
  rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet,
  options?: Partial<ReplaceOptions>
)

    return {
      ...result,
      value: computeValue(result.value),
      purpose: result.purpose ?? purpose,
    };
  }

  if (!isExpression(result)) {
    throw new Error(
      'Invalid rule replacement result: expected a Expression or RuleStep'
    );
  }

  return stepOf(computeValue(result));
}

/**
 * Apply the rules in the ruleset and return a modified expression
 * and the set of rules that were applied.
 *
 * The `replace` function can be used to apply a rule to a non-canonical
 * expression.
 *
 * **Error handling contract.** A single misbehaving rule never aborts the
 * whole pass. An exception thrown while checking a rule's `condition` or while
 * running its `replace` function is logged and that one rule is skipped; the
 * remaining rules are still tried (see `applyRule`). Only a
 * `CancellationError` (deadline/interrupt) propagates out, so timeouts are not
 * swallowed as "the rule failed".
 *
 * **Ordering contract** (SYMBOLIC P3-14). Rules are tried in declaration
 * order. Within a pass, after rule *k* fires, only rules with ordinal > k
 * are tried on the result — earlier rules do not see later rules' output
 * unless another iteration runs. The default `iterationLimit` is **1**, so
 * by default there is a single pass; pass a larger `iterationLimit` (or use
 * `simplify()`, which iterates to a fixed point with its own guards) when
 * rules are meant to feed each other.
 *
 * **Capture convention** (SYMBOLIC P3-13). When several distinct bindings
 * of a pattern's sequence wildcards would match, which one is produced is
 * operator-dependent: the commutative-anchor path and the plain
 * argument-list path resolve greedy-vs-lazy differently. Both results are
 * valid matches; replacements built from captures should not rely on a
 * specific split.
 */
export function replace(
  expr: Expression,
  rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet,
  options?: Partial<ReplaceOptions>
): RuleSteps {
  if (!rules) throw new Error('replace(): Expected one or more rules');

  const iterationLimit = options?.iterationLimit ?? 1;
  let iterationCount = 0;
  const once = options?.once ?? false;
  normalizeReplaceForm(options);

  // Normalize the ruleset
  let ruleSet: ReadonlyArray<BoxedRule>;
  if (typeof rules === 'object' && 'rules' in rules) ruleSet = rules.rules;