Function parseRule

src/compute-engine/boxed-expression/rules.ts:497–721

A rule can be expressed as a string of the form * ` -> ; ` * where ` `, ` ` and ` ` are LaTeX expressions.

(
  ce: ComputeEngine,
  rule: string,
  options?: { canonical?: boolean; purpose?: RulePurpose }
)

    }
    return expr;
  }
  const canonical =
    options?.canonical ??
    (rule instanceof _BoxedExpression ? rule.isCanonical : false);
  return ce.expr(rule, { form: canonical ? 'canonical' : 'raw' });
}

/** A rule can be expressed as a string of the form
 * `<match> -> <replace>; <condition>`
 * where `<match>`, `<replace>` and `<condition>` are LaTeX expressions.
 */
function parseRule(
  ce: ComputeEngine,
  rule: string,
  options?: { canonical?: boolean; purpose?: RulePurpose }
): BoxedRule {
  const makeWildcardEntry = (x: string) => {
    return {
      kind: 'symbol',
      latexTrigger: x,
      // domain: { kind: 'Any' },
      parse: (parser: Parser, _until?: Readonly<Terminator>) => {
        if (!wildcards[x]) wildcards[x] = `_${x}`;
        // conditions are `:condition` or `:condition1,condition2,...`
        // or `:\mathrm{condition}`
        const conditions = parseModifierExpression(parser);
        if (conditions !== null) {
          if (!wildcardConditions[x]) wildcardConditions[x] = conditions;
          else wildcardConditions[x] += ',' + conditions;
        }
        return wildcards[x];
      },
    };
  };

  // Setup custom dictionary entries for ...x, ...x?
  // mapping to wildcard sequence, wildcard optional sequence

  // A mapping from a symbol to a wildcard
  const wildcards: Record<string, string> = {};

  // A mapping from a symbol to a condition
  const wildcardConditions: Record<string, string> = {};

  // Add wildcard entries for all lowercase letters, except
  // for e (natural number), d (differential) and i (imaginary unit)
  const ruleDict = [
    ...LATEX_DICTIONARY,
    {
      kind: 'prefix',
      precedence: 100,
      latexTrigger: '...',
      parse: (parser: Parser, _until?: Readonly<Terminator>) => {
        const id = parser.nextToken();
        if (!'abcfghjklmnopqrstuvwxyz'.includes(id)) return null;
        let prefix = '__';
        // Optional wildcard sequence?
        if (parser.match('?')) prefix = '___';