arch: the great renaming phase 3

arnog · arnog · commit 3f67e02c7b0d · 2026-02-10T15:58:31.000-08:00
diff --git a/test/compute-engine/benchmarks/expand.test.ts b/test/compute-engine/benchmarks/expand.test.ts
@@ -1,11 +1,11 @@
-import type { BoxedExpression } from '../../../src/compute-engine/public';
+import type { Expression } from '../../../src/compute-engine/public';
 import { benchmark, engine } from '../../utils';
 
 //
 // Expand Benchmark
 //
 
-function expand(e: BoxedExpression): BoxedExpression {
+function expand(e: Expression): Expression {
   return engine.box(['Expand', e]).evaluate();
 }
 
diff --git a/test/compute-engine/benchmarks/grudnitski.test.ts b/test/compute-engine/benchmarks/grudnitski.test.ts
@@ -1,13 +1,13 @@
-import { BoxedExpression, ComputeEngine } from '../../../src/compute-engine';
+import { Expression, ComputeEngine } from '../../../src/compute-engine';
 
 export const ce = new ComputeEngine();
 
-function isEquivalent(a: string | BoxedExpression, b: string): boolean {
+function isEquivalent(a: string | Expression, b: string): boolean {
   const lhs = typeof a === 'string' ? ce.parse(a) : a;
   return lhs.isSame(ce.parse(b));
 }
 
-function isEquivalentSimplify(a: string | BoxedExpression, b: string): boolean {
+function isEquivalentSimplify(a: string | Expression, b: string): boolean {
   const lhs = typeof a === 'string' ? ce.parse(a) : a;
   return lhs.simplify().isSame(ce.parse(b).simplify());
 }
diff --git a/test/compute-engine/canonical-form.test.ts b/test/compute-engine/canonical-form.test.ts
@@ -671,7 +671,7 @@ describe('CANONICAL FORMS', () => {
         canonical  = ["Power", "a", 12]
       `);
       //note: 'Multiply' args. are ordered in the output JSON: but the result 'Power'
-      //BoxedExpression still has (ordered) operands [b, c].
+      //Expression still has (ordered) operands [b, c].
       expect(checkPower('{a^{{b^2}^e}}^{0.5*\\pi}')).toMatchInlineSnapshot(`
         box        = [
           "Power",
diff --git a/test/compute-engine/compile-plugin.test.ts b/test/compute-engine/compile-plugin.test.ts
@@ -1,7 +1,7 @@
 import { engine as ce } from '../utils';
 import { compile } from '../../src/compute-engine/compilation/compile-expression';
 import type { LanguageTarget, CompileTarget, CompiledOperators, CompiledFunctions, CompilationResult } from '../../src/compute-engine/compilation/types';
-import type { BoxedExpression } from '../../src/compute-engine/global-types';
+import type { Expression } from '../../src/compute-engine/global-types';
 
 /**
  * Example custom target: Python-like compilation
@@ -47,7 +47,7 @@ class PythonTarget implements LanguageTarget {
   }
 
   compile(
-    expr: BoxedExpression,
+    expr: Expression,
     options: any = {}
   ): CompilationResult {
     const { BaseCompiler } = require('../../src/compute-engine/compilation/base-compiler');
@@ -101,7 +101,7 @@ class RPNTarget implements LanguageTarget {
     };
   }
 
-  compile(expr: BoxedExpression, options: any = {}): CompilationResult {
+  compile(expr: Expression, options: any = {}): CompilationResult {
     const { BaseCompiler } = require('../../src/compute-engine/compilation/base-compiler');
     const target = this.createTarget();
     const rpnCode = BaseCompiler.compile(expr, target);
diff --git a/test/compute-engine/derivatives.test.ts b/test/compute-engine/derivatives.test.ts
@@ -1,14 +1,14 @@
-import type { BoxedExpression } from '../../src/compute-engine/global-types';
+import type { Expression } from '../../src/compute-engine/global-types';
 import { engine } from '../utils';
 
-function parse(expr: string): BoxedExpression {
+function parse(expr: string): Expression {
   return engine.parse(expr)!;
 }
 
 // Helper to create D expressions using MathJSON directly
 // Note: D(f, x) in LaTeX now parses as Predicate, not the derivative function.
 // Use this helper or Leibniz notation (\frac{d}{dx}) for derivatives.
-function D(expr: string, ...vars: string[]): BoxedExpression {
+function D(expr: string, ...vars: string[]): Expression {
   return engine.box(['D', engine.parse(expr), ...vars]);
 }
 
diff --git a/test/compute-engine/extension-contracts.test.ts b/test/compute-engine/extension-contracts.test.ts
@@ -8,20 +8,20 @@ import type {
   CompilationResult,
   LanguageTarget,
 } from '../../src/compute-engine/compilation/types';
-import type { BoxedExpression, LibraryDefinition } from '../../src/compute-engine/global-types';
+import type { Expression, LibraryDefinition } from '../../src/compute-engine/global-types';
 
-class ContractTarget implements LanguageTarget<BoxedExpression> {
+class ContractTarget implements LanguageTarget<Expression> {
   getOperators(): CompiledOperators {
     return { Add: ['+', 11] };
   }
 
-  getFunctions(): CompiledFunctions<BoxedExpression> {
+  getFunctions(): CompiledFunctions<Expression> {
     return {};
   }
 
   createTarget(
-    options: Partial<CompileTarget<BoxedExpression>> = {}
-  ): CompileTarget<BoxedExpression> {
+    options: Partial<CompileTarget<Expression>> = {}
+  ): CompileTarget<Expression> {
     const ops = this.getOperators();
     const fns = this.getFunctions();
     return {
@@ -38,7 +38,7 @@ class ContractTarget implements LanguageTarget<BoxedExpression> {
     };
   }
 
-  compile(expr: BoxedExpression): CompilationResult {
+  compile(expr: Expression): CompilationResult {
     const { BaseCompiler } = require('../../src/compute-engine/compilation/base-compiler');
     return {
       target: 'contract',
@@ -105,7 +105,7 @@ describe('Extension Contracts', () => {
         number: (n: number) => String(n),
         preamble: '',
         indent: 0,
-      } as unknown as CompileTarget<BoxedExpression>;
+      } as unknown as CompileTarget<Expression>;
 
       expect(() => compile(expr, { target: invalidTarget })).toThrow(/"ws\(\)"/);
     });
@@ -141,7 +141,7 @@ describe('Extension Contracts', () => {
 
     test('rejects target objects that do not implement LanguageTarget', () => {
       const ce = new ComputeEngine();
-      const invalidTarget = {} as unknown as LanguageTarget<BoxedExpression>;
+      const invalidTarget = {} as unknown as LanguageTarget<Expression>;
 
       expect(() =>
         ce.registerCompilationTarget('broken-target', invalidTarget)
@@ -246,15 +246,15 @@ describe('Extension Contracts', () => {
       const rules = ce.rules([
         {
           match: 'x',
-          replace: () => 'not-an-expression' as unknown as BoxedExpression,
+          replace: () => 'not-an-expression' as unknown as Expression,
         },
       ]);
 
       const expr = ce.parse('x');
       const rule = rules.rules[0];
 
       expect(() => applyRule(rule, expr, {})).toThrow(
-        /expected a BoxedExpression or RuleStep/
+        /expected a Expression or RuleStep/
       );
     });
   });
diff --git a/test/compute-engine/factor.test.ts b/test/compute-engine/factor.test.ts
@@ -1,4 +1,4 @@
-import { BoxedExpression, ComputeEngine } from '../../src/compute-engine';
+import { Expression, ComputeEngine } from '../../src/compute-engine';
 import {
   factorPerfectSquare,
   factorDifferenceOfSquares,
@@ -8,7 +8,7 @@ import {
 
 const ce = new ComputeEngine();
 
-function parse(latex: string): BoxedExpression {
+function parse(latex: string): Expression {
   return ce.parse(latex);
 }
 
diff --git a/test/compute-engine/numbers.test.ts b/test/compute-engine/numbers.test.ts
@@ -1,5 +1,5 @@
 import { Expression } from '../../src/math-json/types.ts';
-import type { BoxedExpression } from '../../src/compute-engine/global-types.ts';
+import type { Expression } from '../../src/compute-engine/global-types.ts';
 import { engine as ce } from '../utils';
 
 describe('BOXING OF NUMBER', () => {
@@ -50,7 +50,7 @@ describe('BOXING OF NUMBER', () => {
   });
 });
 
-function checkProps(x: BoxedExpression): string {
+function checkProps(x: Expression): string {
   const result: string[] = [];
   result.push('number literal: ' + x.isNumberLiteral);
   result.push('type: ' + x.type.toString());
diff --git a/test/compute-engine/oeis.test.ts b/test/compute-engine/oeis.test.ts
@@ -47,7 +47,7 @@ describeIfNetwork('OEIS Integration (SUB-12)', () => {
       expect(Array.isArray(results)).toBe(true);
     });
 
-    test('handles BoxedExpression terms', async () => {
+    test('handles Expression terms', async () => {
       const ce = new ComputeEngine();
       const terms = [
         ce.number(0),
diff --git a/test/compute-engine/patterns.test.ts b/test/compute-engine/patterns.test.ts
@@ -1,27 +1,27 @@
 import {
-  BoxedExpression,
+  Expression,
   PatternMatchOptions,
   ExpressionInput,
   Substitution,
 } from '../../src/compute-engine';
 import { _BoxedExpression } from '../../src/compute-engine/boxed-expression/abstract-boxed-expression';
 import { validatePattern } from '../../src/compute-engine/boxed-expression/boxed-patterns';
-import { MathJsonExpression as Expression } from '../../src/math-json/types';
+import { MathJsonExpression } from '../../src/math-json/types';
 import { engine, latex } from '../utils';
 
 const ce = engine;
 
 function match(
   pattern: ExpressionInput,
-  expr: BoxedExpression | Expression,
+  expr: Expression | MathJsonExpression,
   options?: PatternMatchOptions
 ): Substitution | null {
   // Avoid re-boxing both expr & pattern so as to preserve canonical-status
   expr =
-    expr instanceof _BoxedExpression ? (expr as BoxedExpression) : ce.box(expr);
+    expr instanceof _BoxedExpression ? (expr as Expression) : ce.box(expr);
   pattern =
     pattern instanceof _BoxedExpression
-      ? (pattern as BoxedExpression)
+      ? (pattern as Expression)
       : ce.box(pattern);
 
   const result = expr.match(pattern, {
@@ -35,7 +35,7 @@ function match(
 }
 
 describe('Examples from Patterns and Rules guide', () => {
-  const pattern: Expression = ['Add', '_', 'x'];
+  const pattern: MathJsonExpression = ['Add', '_', 'x'];
 
   // console.log("x+42", ce.box(["Add", "x", 42]).match(pattern));
   // ➔ { } : the expression matches the pattern by commutativity
@@ -970,7 +970,7 @@ describe('NON EXACT WILDCARDS', () => {
   });
 });
 
-// GitHub Issue #258: BoxedExpression.match() with a Rational pattern
+// GitHub Issue #258: Expression.match() with a Rational pattern
 describe('RATIONAL PATTERN MATCHING', () => {
   it('should match Rational(3, 2) with Rational pattern', () => {
     // Rational with two integers becomes a BoxedNumber
diff --git a/test/compute-engine/sequences.test.ts b/test/compute-engine/sequences.test.ts
@@ -57,7 +57,7 @@ describe('DECLARATIVE SEQUENCE DEFINITIONS', () => {
       expect(ce.parse('T_{5}').evaluate().re).toBe(15);
     });
 
-    test('Sequence with BoxedExpression base case', () => {
+    test('Sequence with Expression base case', () => {
       const ce = new ComputeEngine();
       ce.declareSequence('B', {
         base: { 0: ce.number(10) },
diff --git a/test/compute-engine/type-guards.test.ts b/test/compute-engine/type-guards.test.ts
@@ -92,7 +92,7 @@ describe('isFunction', () => {
   test('narrows type to FunctionInterface', () => {
     const expr = ce.parse('x + 1');
     if (isFunction(expr)) {
-      // After guard, ops is ReadonlyArray<BoxedExpression> (no undefined)
+      // After guard, ops is ReadonlyArray<Expression> (no undefined)
       expect(expr.ops.length).toBeGreaterThan(0);
       expect(expr.nops).toBeGreaterThan(0);
       expect(expr.isFunctionExpression).toBe(true);
diff --git a/test/compute-engine/workflow-entrypoints.test.ts b/test/compute-engine/workflow-entrypoints.test.ts
@@ -14,7 +14,7 @@ import {
 } from '../../src/compute-engine';
 
 describe('Free Functions', () => {
-  test('parse() returns a BoxedExpression', () => {
+  test('parse() returns a Expression', () => {
     const result = parse('x^2');
     expect(result).toBeDefined();
     expect(result.operator).toBe('Power');
@@ -25,7 +25,7 @@ describe('Free Functions', () => {
     expect(result.toString()).toBe('2x + 1');
   });
 
-  test('simplify() simplifies an existing BoxedExpression', () => {
+  test('simplify() simplifies an existing Expression', () => {
     const expr = parse('x + x + 1');
     const result = simplify(expr);
     expect(result.toString()).toBe('2x + 1');
@@ -36,7 +36,7 @@ describe('Free Functions', () => {
     expect(result.toString()).toBe('2047');
   });
 
-  test('evaluate() evaluates an existing BoxedExpression', () => {
+  test('evaluate() evaluates an existing Expression', () => {
     const expr = parse('2^{11} - 1');
     const result = evaluate(expr);
     expect(result.toString()).toBe('2047');
@@ -50,7 +50,7 @@ describe('Free Functions', () => {
     expect(result.toString()).not.toBe('Sqrt(2)');
   });
 
-  test('N() returns numeric approximation from BoxedExpression', () => {
+  test('N() returns numeric approximation from Expression', () => {
     const expr = parse('\\sqrt{2}');
     const result = N(expr);
     expect(result).toBeDefined();
@@ -101,7 +101,7 @@ describe('Free Functions', () => {
     expect(result!.latex).toBe('x^2+2x+1');
   });
 
-  test('expand() expands a BoxedExpression', () => {
+  test('expand() expands a Expression', () => {
     const expr = parse('(x+1)(x+2)');
     const result = expand(expr);
     expect(result).not.toBeNull();
@@ -117,7 +117,7 @@ describe('Free Functions', () => {
     expect(values).toContain(3);
   });
 
-  test('solve() solves from a BoxedExpression', () => {
+  test('solve() solves from a Expression', () => {
     const expr = parse('x^2 - 5x + 6 = 0');
     const result = solve(expr, 'x');
     expect(result).not.toBeNull();
@@ -132,7 +132,7 @@ describe('Free Functions', () => {
     expect(result).not.toBeNull();
   });
 
-  test('expandAll() expands from a BoxedExpression', () => {
+  test('expandAll() expands from a Expression', () => {
     const expr = parse('(x+1)^2');
     const result = expandAll(expr);
     expect(result).not.toBeNull();
@@ -145,7 +145,7 @@ describe('Free Functions', () => {
     expect(result.latex).toBe('8xy');
   });
 
-  test('factor() factors from a BoxedExpression', () => {
+  test('factor() factors from a Expression', () => {
     const expr = parse('(2x)(4y)');
     const result = factor(expr);
     expect(result).toBeDefined();
@@ -159,7 +159,7 @@ describe('Free Functions', () => {
     expect(typeof result.code).toBe('string');
   });
 
-  test('compile() compiles from a BoxedExpression', () => {
+  test('compile() compiles from a Expression', () => {
     const expr = parse('x^2 + 1');
     const result = compile(expr);
     expect(result).toBeDefined();
diff --git a/test/public-ts-declarations/main.ts b/test/public-ts-declarations/main.ts
@@ -1,5 +1,5 @@
 import { ComputeEngine, version } from 'compute-engine';
-import type { BoxedExpression, Parser } from 'compute-engine';
+import type { Parser } from 'compute-engine';
 
 console.log(version);
 const ce = new ComputeEngine();
@@ -24,5 +24,5 @@ ce.declare('Ln', {
   },
 });
 
-const expr: BoxedExpression = ce.parse('x^2 + 2x + 1');
+const expr = ce.parse('x^2 + 2x + 1');
 console.log(expr.toString());
diff --git a/test/utils.ts b/test/utils.ts
@@ -412,7 +412,7 @@ function emoji(a, b): string {
 
 // Serializer for Boxed Expressions
 expect.addSnapshotSerializer({
-  // Is the value to serialize an instance of the BoxedExpression class?
+  // Is the value to serialize an instance of the Expression class?
   test: (val): boolean => val && val instanceof _BoxedExpression,
 
   serialize: (val, _config, _indentation, _depth, _refs, _printer): string =>

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`		`-import { BoxedExpression, ComputeEngine } from '../../../src/compute-engine';`
	`1`	`+import { Expression, ComputeEngine } from '../../../src/compute-engine';`
`2`	`2`
`3`	`3`	`export const ce = new ComputeEngine();`
`4`	`4`
`5`		`-function isEquivalent(a: string \| BoxedExpression, b: string): boolean {`
	`5`	`+function isEquivalent(a: string \| Expression, b: string): boolean {`
`6`	`6`	`const lhs = typeof a === 'string' ? ce.parse(a) : a;`
`7`	`7`	`return lhs.isSame(ce.parse(b));`
`8`	`8`	`}`
`9`	`9`
`10`		`-function isEquivalentSimplify(a: string \| BoxedExpression, b: string): boolean {`
	`10`	`+function isEquivalentSimplify(a: string \| Expression, b: string): boolean {`
`11`	`11`	`const lhs = typeof a === 'string' ? ce.parse(a) : a;`
`12`	`12`	`return lhs.simplify().isSame(ce.parse(b).simplify());`
`13`	`13`	`}`