@cortex-js/compute-engine 0.5.0 → 0.7.0

package/dist/types/compute-engine/public.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -17,18 +17,18 @@ export * from './latex-syntax/public';
  * Metadata that can be associated with a `BoxedExpression`
  */
 export declare type Metadata = {
-    latex?: string;
-    wikidata?: string;
+    latex?: string | undefined;
+    wikidata?: string | undefined;
 };
 /**
  * The numeric evaluation mode:
  *
- * - `auto`: use machine number if precision is 15 or less, allow complex numbers.
- * - `machine`: 64-bit float, **IEEE 754-2008**, 64-bit float, 52-bit mantissa,
+ * - `"auto"`: use machine number if precision is 15 or less, allow complex numbers.
+ * - `"machine"`: 64-bit float, **IEEE 754-2008**, 64-bit float, 52-bit mantissa,
  *    about 15 digits of precision
- * - `decimal`: arbitrary precision floating point numbers, as provided by the
+ * - `"decimal"`: arbitrary precision floating point numbers, as provided by the
  * "decimal.js" library
- * - `complex`: complex number represented by two machine numbers, a real and
+ * - `"complex"`: complex number represented by two machine numbers, a real and
  * an imaginary part, as provided by the "complex.js" library
  */
 export declare type NumericMode = 'auto' | 'machine' | 'decimal' | 'complex';
@@ -49,16 +49,16 @@ export declare type EvaluateOptions = {};
  */
 export declare type NOptions = {};
 export declare type ReplaceOptions = {
-    /** If true, apply replacement rules to all sub-expressions.
-     * If false, only consider the top-level expression.
+    /** If `true`, apply replacement rules to all sub-expressions.
+     * If `false`, only consider the top-level expression.
      *
      * **Default**: `true`
      */
     recursive?: boolean;
     /**
-     * If true, stop after the first rule that matches.
+     * If `true`, stop after the first rule that matches.
      *
-     * If false, apply all the remaining rules even after the first match.
+     * If `false`, apply all the remaining rules even after the first match.
      *
      * **Default**: `true`
      */
@@ -81,6 +81,9 @@ export declare type ReplaceOptions = {
  * rule whose `lhs` is always a symbol.
  */
 export declare type Substitution = {
+    [symbol: string]: SemiBoxedExpression;
+};
+export declare type BoxedSubstitution = {
     [symbol: string]: BoxedExpression;
 };
 /** A LaTeX string starts and end with `$`, for example
@@ -111,7 +114,7 @@ export declare type Rule = [
     lhs: LatexString | SemiBoxedExpression | Pattern,
     rhs: LatexString | SemiBoxedExpression,
     options?: {
-        condition?: LatexString | ((wildcards: Substitution) => boolean);
+        condition?: LatexString | ((wildcards: BoxedSubstitution) => boolean);
         priority?: number;
     }
 ];
@@ -119,16 +122,55 @@ export declare type BoxedRule = [
     lhs: Pattern,
     rhs: BoxedExpression,
     priority: number,
-    condition: undefined | ((wildcards: Substitution) => boolean)
+    condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
 ];
 export declare type BoxedRuleSet = Set<BoxedRule>;
-/**
- * Domains can be defined as a union or intersection of domains:
- * - `["Union", "Number", "Boolean"]` A number or a boolean.
- * - `["SetMinus", "Number", 1]`  Any number except "1".
- *
- */
-export declare type DomainExpression = BoxedExpression;
+export declare type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+/** A domain constructor is the head of a domain expression. */
+export declare type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+export declare type DomainLiteral = string;
+export declare type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
+export interface BoxedDomain extends BoxedExpression {
+    is(s: BoxedDomain): boolean;
+    /** True if a valid domain, and compatible with `dom` */
+    isCompatible(dom: BoxedDomain | DomainLiteral, kind?: DomainCompatibility): boolean;
+    get literal(): string | null;
+    get ctor(): DomainConstructor | null;
+    get domainArgs(): (DomainExpression<BoxedExpression> | BoxedExpression | string)[] | null;
+    get domainArg1(): string | BoxedExpression | DomainExpression<BoxedExpression> | null;
+    get codomain(): BoxedDomain | null;
+    get canonical(): BoxedDomain;
+    get json(): Expression;
+    readonly isNothing: boolean;
+    readonly isNumeric: boolean;
+    readonly isFunction: boolean;
+    /**
+     * If true, when all the arguments are numeric, the result of the
+     * evaluation is numeric. Numeric is any value with a domain of `Number`.
+     *
+     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
+     *
+     * Default: `false`
+     */
+    /**
+     * If true, when all the arguments are boolean, the result of the
+     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
+     *
+     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
+     *
+     * **Default:** `false`
+     */
+    /**
+     * The function represent a relation between the first argument and
+     * the second argument, and evaluates to a boolean indicating if the relation
+     * is satisfied.
+     *
+     * For example, `Equal`, `Less`, `Approx`, etc...
+     *
+     * **Default:** `false`
+     */
+    readonly isRelationalOperator: boolean;
+}
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
  */
@@ -148,7 +190,7 @@ export declare type JsonSerializationOptions = {
     /** A list of space separated keywords indicating which MathJSON expressions
      * can use a shorthand.
      *
-     * **Default**: `['all']`
+     * **Default**: `["all"]`
      */
     shorthands: ('all' | 'number' | 'symbol' | 'function' | 'dictionary' | 'string')[];
     /** A list of space separated keywords indicating which metadata should be
@@ -216,7 +258,7 @@ export interface BoxedExpression {
      * @category Object Methods
      *
      */
-    is(rhs: any): boolean;
+    is(rhs: unknown): boolean;
     /** @internal */
     get hash(): number;
     /** An optional short description of the symbol or function head.
@@ -240,7 +282,7 @@ export interface BoxedExpression {
     get value(): BoxedExpression | undefined;
     /** Only the value of variables can be changed (symbols that are not constants) */
     set value(value: BoxedExpression | number | undefined);
-    /** Return an approximation of the value of this expression. Floating-point
+    /** An approximation of the value of this expression. Floating-point
      * operations may be performed.
      *
      * Just like `this.value`, it returns `undefined` for impure expressions.
@@ -257,6 +299,10 @@ export interface BoxedExpression {
      * As an example, the `Random` function is not pure.
      */
     get isPure(): boolean;
+    /** True if the expression is a free variable, that is a symbol with no value */
+    get isFree(): boolean;
+    /** True if the expression is a constant, that is a symbol with an immutable value */
+    get isConstant(): boolean;
     /**
      * If `true`, this expression represents a value that was not calculated
      * or that does not reference another expression.
@@ -270,6 +316,14 @@ export interface BoxedExpression {
      * @internal
      */
     set isCanonical(val: boolean);
+    /** All the subexpressions matching the head */
+    getSubexpressions(head: string): BoxedExpression[];
+    /** All the subexpressions in this expression, recursively */
+    get subexpressions(): BoxedExpression[];
+    /** All the symbols in the expression, recursively */
+    get symbols(): BoxedExpression[];
+    /** All the `["Error"]` subexpressions */
+    get errors(): BoxedExpression[];
     /** `ops` is the list of arguments of the function, its "tail"
      *
      * @category Function Expression
@@ -412,7 +466,7 @@ export interface BoxedExpression {
      * performed if they are safe from overflow. This method makes it easy
      * to check for this, whether the value is a Decimal or a number.
      *
-     * By default, "small" is less than 10,000.
+     * By default, "small" is less than 1,000,000.
      *
      * @category Numeric Expression
      *
@@ -441,8 +495,9 @@ export interface BoxedExpression {
      * Note that complex numbers have no natural ordering,
      * so if the value is a complex number, `sgn` is either 0, or `null`
      *
-     * If a symbol, this does take assumptions into account, that is `this.sgn` will return
-     * `1` if `isPositive` is `true`, even if this expression has no value
+     * If a symbol, this does take assumptions into account, that is `this.sgn`
+     * will return `1` if `isPositive` is `true`, even if this expression has
+     * no value
      *
      * @category Numeric Expression
      *
@@ -455,12 +510,17 @@ export interface BoxedExpression {
      *
      */
     get symbol(): string | null;
-    /**  Shortcut for `this.symbol === "Missing"`
+    /**
+     * If this is the `Nothing`, return `true`.
+     */
+    get isNothing(): boolean;
+    /** `true` if this expression or any subexpression is an `["Error"]`
+     * expression.
      *
      * @category Symbol Expression
      *
      */
-    get isMissing(): boolean;
+    get isValid(): boolean;
     /** If this expression is a string, return the value of the string.
      * Otherwise, return `null`.
      *
@@ -468,18 +528,12 @@ export interface BoxedExpression {
      *
      */
     get string(): string | null;
-    /** True if this domain is a subset of domain `d`
-     *
-     * @category Expression Properties
-     *
-     */
-    isSubsetOf(d: BoxedExpression | string): undefined | boolean;
-    /** True if the value of this expression is a number.
+    /** `true` if the value of this expression is a number.
      *
      * `isExtendedComplex || isNaN` = `isReal || isImaginary || isInfinity || isNaN`
      *
      * Note that in a fateful twist of cosmic irony, `NaN` ("Not a Number")
-     * is a number.
+     * **is** a number.
      *
      * @category Expression Properties
      */
@@ -586,7 +640,7 @@ export interface BoxedExpression {
      *
      */
     get isNaN(): boolean | undefined;
-    /** Not ±Infinity and not `NaN`
+    /** This expression is a number, but not ±Infinity and not `NaN`
      *
      * @category Expression Properties
      */
@@ -644,7 +698,7 @@ export interface BoxedExpression {
      * @category Relational Operator
      */
     isEqual(rhs: BoxedExpression): boolean;
-    /** If the expressions cannot be compared, `undefined` is returned
+    /** If the expressions cannot be compared, return `undefined`
      *
      * @category Relational Operator
      */
@@ -666,17 +720,17 @@ export interface BoxedExpression {
      * @category Expression Properties
      */
     get isPositive(): boolean | undefined;
-    /** The value of this expression is  >= 0, same as `isGreaterEqual(0)`
+    /** The value of this expression is >= 0, same as `isGreaterEqual(0)`
      *
      * @category Expression Properties
      */
     get isNonNegative(): boolean | undefined;
-    /** The value of this expression is  < 0, same as `isLess(0)`
+    /** The value of this expression is < 0, same as `isLess(0)`
      *
      * @category Expression Properties
      */
     get isNegative(): boolean | undefined;
-    /** The value of this expression is  <= 0, same as `isLessEqual(0)`
+    /** The value of this expression is <= 0, same as `isLessEqual(0)`
      *
      * @category Expression Properties
      */
@@ -693,12 +747,28 @@ export interface BoxedExpression {
      * first in commutative functions
      */
     get complexity(): number;
-    /** The domain of this expression, using the value of the expression,
-     * definitions associated with this expression and assumptions if necessary */
-    get domain(): BoxedExpression;
-    /** Symbols that represent a variable, can have their domain modified */
-    set domain(domain: BoxedExpression | string);
-    /** For symbols and functions, a possible definition associated with the expression */
+    /** The domain of this expression. If a function expression, this the domain
+     * of the value of the function(the codomain of the function), if a symbol
+     * the domain of the value of the symbol.
+     */
+    get domain(): BoxedDomain;
+    /** Symbols that represent a variable (or a function name), can have their
+     *  domain modified */
+    set domain(domain: BoxedDomain | string);
+    /**
+     * The domain of this expression, without accounting for any inferred domain
+     * or `defaultDomain`. If no domain has been explicitly set via assignment
+     * or via an `.assume()` directive, the `expr.explicitDomain` is `null.
+     *
+     * This is useful to determine if the domain of an expression is inferred.
+     *
+     * In most cases you'll want to  use `.domain` instead.
+     */
+    get explicitDomain(): BoxedDomain | null;
+    /** For symbols and functions, a possible definition associated with the
+     *  expression. `basedDefinition` is the base class of symbol and function
+     *  definition. */
+    get basedDefinition(): BoxedBaseDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     /**
@@ -785,6 +855,7 @@ export interface BoxedExpression {
     solve(vars: Iterable<string>): null | BoxedExpression[];
     /**
      * If this expression is a function, apply the function `fn` to all its operands.
+     *
      * Replace the head of this expression with `head`, if defined.
      *
      * If this expression is a dictionary, return a new dictionary with the values
@@ -813,16 +884,16 @@ export interface BoxedExpression {
     subs(sub: Substitution): BoxedExpression;
     /**
      * Update the definition associated with this expression, taking
-     * into account the current context.
+     * into account the specified scope.
      *
      * @internal
      */
-    _repairDefinition(): void;
+    bind(scope: RuntimeScope | null): void;
     /** Purge any cached values.
      *
      * @internal
      */
-    _purge(): undefined;
+    unbind(): void;
 }
 /** A semi boxed expression is an MathJSON expression which can include some
  * boxed terms.
@@ -847,7 +918,7 @@ export interface Pattern extends BoxedExpression {
      * equal to the expression. If there are no named wildcards and the expression
      * matches the pattern, and empty object literal `{}` is returned.
      */
-    match(expr: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    match(expr: BoxedExpression, options?: PatternMatchOption): BoxedSubstitution | null;
     /** If `expr` matches the pattern, return `true`, otherwise `false` */
     test(expr: BoxedExpression, options?: PatternMatchOption): boolean;
     /** Return the number of exprs that matched the pattern */
@@ -863,25 +934,25 @@ export interface ExpressionMapInterface<U> {
     [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
 }
 /**
- * A dictionary contains definitions for symbols, functions and rules.
+ * A symbol table contains definitions for symbols, functions and rules.
  *
  */
-export declare type Dictionary = {
+export declare type SymbolTable = {
     symbols?: SymbolDefinition[];
     functions?: FunctionDefinition[];
     simplifyRules?: BoxedRuleSet;
 };
 /**
- * The entries of a `CompiledDictionary` have been validated and
+ * The entries of a `RuntimeSymbolTable` have been validated and
  * optimized for faster evaluation.
  *
  * When a new scope is created with `pushScope()` or when creating a new
  * engine instance, new instances of `RuntimeDictionary` are created as needed.
  */
-export declare type RuntimeDictionary = {
+export declare type RuntimeSymbolTable = {
     symbols: Map<string, BoxedSymbolDefinition>;
     symbolWikidata: Map<string, BoxedSymbolDefinition>;
-    functions: Map<string, BoxedFunctionDefinition[]>;
+    functions: Map<string, BoxedFunctionDefinition>;
     functionWikidata: Map<string, BoxedFunctionDefinition>;
 };
 /**
@@ -930,7 +1001,7 @@ export declare type Scope = {
 };
 export declare type RuntimeScope = Scope & {
     parentScope: RuntimeScope;
-    dictionary?: RuntimeDictionary;
+    symbolTable?: RuntimeSymbolTable;
     assumptions: undefined | ExpressionMapInterface<boolean>;
     /** The location of the call site that created this scope */
     origin?: {
@@ -949,9 +1020,9 @@ export declare type BaseDefinition = {
      * The name of a symbol or function is an arbitrary string of Unicode
      * characters, however the following conventions are recommended:
      *
-     * - Use only letters, digits and `-`, and the first character should be
-     * a letter: `/^[a-zA-Z][a-zA-Z0-9-]+/`
-     * - Built-in functions and symbols should start with an uppercase letter
+     * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
+     * - The first character should be a letter: `/^[a-zA-Z]/`
+     * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
      *
      */
     name: string;
@@ -966,20 +1037,8 @@ export declare type BaseDefinition = {
      * for the `Pi` constant.
      */
     wikidata?: string;
-    /**
-     * The domain of this item.
-     *
-     * For dictionaries, this is the domain of all the items in the dictionary.
-     *
-     * For strings, it's always 'String'.
-     *
-     * For symbols, this is the domain of their value.
-     *
-     * For functions, this is the domain of their result (aka codomain)
-     */
-    domain?: BoxedExpression | string;
 };
-export declare type BoxedBaseDefinition = {
+export interface BoxedBaseDefinition {
     name: string;
     wikidata?: string;
     description?: string | string[];
@@ -990,32 +1049,35 @@ export declare type BoxedBaseDefinition = {
      * This field is usually undefined, but its value is set by `getDefinition()`
      */
     scope: RuntimeScope | undefined;
-    domain?: BoxedExpression;
-    _purge(): undefined;
-};
+    /** When the environment changes, for example the numerical precision,
+     * call `reset()` so that any cached values can be recalculated.
+     */
+    reset(): any;
+}
 /**
  * A function definition can have some flags to indicate specific
  * properties of the function.
  */
 export declare type FunctionDefinitionFlags = {
-    /**  If true, the function is applied element by element to lists, matrices
-     * and equations.
+    /**  If `true`, the function is applied element by element to lists, matrices
+     * (`["List"]` or `["Tuple"]` expressions) and equations (relational
+     * operators).
      *
      * **Default**: `false`
      */
     threadable: boolean;
-    /** If true, `["f", ["f", a], b]` simplifies to `["f", a, b]`
+    /** If `true`, `["f", ["f", a], b]` simplifies to `["f", a, b]`
      *
      * **Default**: `false`
      */
     associative: boolean;
-    /** If true, `["f", a, b]` equals `["f", b, a]`. The canonical
+    /** If `true`, `["f", a, b]` equals `["f", b, a]`. The canonical
      * version of the function will order the arguments.
      *
      * **Default**: `false`
      */
     commutative: boolean;
-    /** If true, when the function is univariate, `["f", ["Add", x, c]]` where `c`
+    /** If `true`, when the function is univariate, `["f", ["Add", x, c]]` where `c`
      * is constant, is simplified to `["Add", ["f", x], c]`.
      *
      * When the function is multivariate, additivity is considered only on the
@@ -1025,7 +1087,7 @@ export declare type FunctionDefinitionFlags = {
      *
      * **Default**: `false`
      */
-    /** If true, when the function is univariate, `["f", ["Multiply", x, y]]`
+    /** If `true`, when the function is univariate, `["f", ["Multiply", x, y]]`
      * simplifies to `["Multiply", ["f", x], ["f", y]]`.
      *
      * When the function is multivariate, multiplicativity is considered only on the
@@ -1034,54 +1096,26 @@ export declare type FunctionDefinitionFlags = {
      *
      * **Default**: `false`
      */
-    /** If true, when the function is univariate, `["f", ["Multiply", x, c]]`
+    /** If `true`, when the function is univariate, `["f", ["Multiply", x, c]]`
      * simplifies to `["Multiply", ["f", x], c]` where `c` is constant
      *
-     * When the function is multivariate, multiplicativity is considered only on the
-     * first argument: `["f", ["Multiply", x, y], z]` simplifies to
+     * When the function is multivariate, multiplicativity is considered only on
+     * the first argument: `["f", ["Multiply", x, y], z]` simplifies to
      * `["Multiply", ["f", x, z], ["f", y, z]]`
      *
      * Default: `false`
      */
-    /** If true, `["f", ["f", x]]` simplifies to `["f", x]`.
+    /** If `true`, `["f", ["f", x]]` simplifies to `["f", x]`.
      *
      * **Default**: `false`
      */
     idempotent: boolean;
-    /** If true, `["f", ["f", x]]` simplifies to `x`.
+    /** If `true`, `["f", ["f", x]]` simplifies to `x`.
      *
      * **Default**: `false`
      */
     involution: boolean;
-    /**
-     * If true, when all the arguments are numeric, the result of the
-     * evaluation is numeric. Numeric is any value with a domain of `Number`.
-     *
-     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
-     *
-     * Default: false
-     */
-    numeric: boolean;
-    /**
-     * If true, when all the arguments are boolean, the result of the
-     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
-     *
-     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
-     *
-     * **Default:** false
-     */
-    logic: boolean;
-    /**
-     * The function represent a relation between the first argument and
-     * the second argument, and evaluates to a boolean indicating if the relation
-     * is satisfied.
-     *
-     * For example, `Equal`, `Less`, `Approx`, etc...
-     *
-     * **Default:** false
-     */
-    relationalOperator: boolean;
-    /** If true, the value of this function is always the same for a given
+    /** If `true`, the value of this function is always the same for a given
      * set of arguments and it has no side effects.
      *
      * An expression using this function is pure if the function and all its
@@ -1091,7 +1125,7 @@ export declare type FunctionDefinitionFlags = {
      *
      * This information may be used to cache the value of expressions.
      *
-     * **Default:** true
+     * **Default:** `true`
      */
     pure: boolean;
     /**
@@ -1102,46 +1136,30 @@ export declare type FunctionDefinitionFlags = {
      * **Default:** false
      */
     inert: boolean;
-};
-/**
- * Definition record for a function.
- *
- */
-export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
-    /**
-     * A number used to order arguments. Argument with higher
-     * complexity are placed after arguments with lower complexity when
-     * ordered canonically in commutative functions.
-     *
-     * - Additive functions: 1000-1999
-     * - Multiplicative functions: 2000-2999
-     * - Root and power functions: 3000-3999
-     * - Log functions: 4000-4999
-     * - Trigonometric functions: 5000-5999
-     * - Hypertrigonometric functions: 6000-6999
-     * - Special functions (factorial, Gamma, ...): 7000-7999
-     * - Collections: 8000-8999
-     * - Inert and styling:  9000-9999
-     * - Logic: 10000-10999
-     * - Relational: 11000-11999
-     *
-     * **Default**: 100,000
-     */
-    complexity?: number;
     /**
-     * - `none` Each of the arguments is evaluated (default)
-     * - `all` None of the arguments are evaluated and they are passed as is
-     * - `first` The first argument is not evaluated, the others are
-     * - `rest` The first argument is evaluated, the others aren't
+     * All the arguments of a numeric function are numeric,
+     * and its value is numeric.
      */
-    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    numeric: boolean;
     /**
-     * If true, `Sequence` arguments appearing in the arguments of a function
-     * should not automatically be flattened out
+     * When true, evaluating the function create a temporary scope.
+     * This is used for example by the `Lambda` function to keep track of the
+     * inferred domain of its wildcard  `_` arguments
      */
-    sequenceHold?: boolean;
+    scoped: boolean;
+};
+/**
+ *
+ */
+export declare type FunctionSignature = {
+    /** The domain of this signature, a domain compatible with the `Function`
+     * domain) */
+    domain?: BoxedDomain | DomainExpression;
     /** The minimum and maximum values of the result of the function */
-    range?: [min: number, max: number];
+    /** An optional handler to determine the codomain of the function.
+     * If not provided, the codomain of the function is determined from `domain`
+     */
+    codomain?: (ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null;
     /**
      * Return the canonical form of the expression with the arguments `args`.
      *
@@ -1252,31 +1270,6 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
      *
      */
     N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    /**
-     *
-     * Calculate the domain of the result, based on the value of the arguments.
-     *
-     * If the domain of the result is always the same, use the `domain` property
-     * instead.
-     *
-     * The argument `args` represent the arguments of the function.
-     *
-     * The return value is `null` if the input arguments cannot be handled by
-     * this definition.
-     *
-     * Otherwise, the return value is the domain of the result.
-     *
-     * Return `"Nothing"` if the arguments are acceptable, but the evaluation
-     * will fail, for example in some cases if there are missing arguments.
-     *
-     * This function is used to select the correct definition when there are
-     * multiple definitions for the same function name.
-     *
-     * For example it allows to distinguish between a `Add` function that
-     * applies to numbers and an `Add` function that applies to tensors.
-     *
-     */
-    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
     /** Dimensional analysis
      * @experimental
      */
@@ -1286,20 +1279,61 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
-export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
-    complexity: number;
-    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
-    sequenceHold: boolean;
-    range?: [min: number, max: number];
+export declare type BoxedFunctionSignature = {
+    domain: BoxedDomain;
+    codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null);
     canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
     simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     evaluate?: BoxedLambdaExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
     N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
     evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
     sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
+/**
+ * Definition record for a function.
+ *
+ */
+export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+    /**
+     * A number used to order arguments.
+     *
+     * Argument with higher complexity are placed after arguments with lower
+     * complexity when ordered canonically in commutative functions.
+     *
+     * - Additive functions: 1000-1999
+     * - Multiplicative functions: 2000-2999
+     * - Root and power functions: 3000-3999
+     * - Log functions: 4000-4999
+     * - Trigonometric functions: 5000-5999
+     * - Hypertrigonometric functions: 6000-6999
+     * - Special functions (factorial, Gamma, ...): 7000-7999
+     * - Collections: 8000-8999
+     * - Inert and styling:  9000-9999
+     * - Logic: 10000-10999
+     * - Relational: 11000-11999
+     *
+     * **Default**: 100,000
+     */
+    complexity?: number;
+    /**
+     * - `"none"` Each of the arguments is evaluated (default)
+     * - `"all"` None of the arguments are evaluated and they are passed as is
+     * - `"first"` The first argument is not evaluated, the others are
+     * - `"rest"` The first argument is evaluated, the others aren't
+     * - `"last"`: The last argument is not evaluated, the others are
+     * - `"most"`: All the arguments are evaluated, except the last one
+     *
+     * **Default**: `"none"`
+     */
+    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    signature?: FunctionSignature;
+};
+export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
+    complexity: number;
+    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    signature: BoxedFunctionSignature;
+};
 /**
  * When used in a `SymbolDefinition`, these flags are optional.
  *
@@ -1361,11 +1395,12 @@ export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & P
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    domain?: string | BoxedExpression;
+    domain?: string | BoxedDomain;
 };
 export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
     get value(): BoxedExpression | undefined;
     set value(val: BoxedExpression | undefined);
+    domain: BoxedDomain | undefined;
     at?: (index: string | number) => undefined | BoxedExpression;
 }
 export declare type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
@@ -1382,41 +1417,41 @@ export interface ComputeEngineStats {
 /** @internal */
 export interface IComputeEngine {
     /** @internal */
-    readonly ZERO: BoxedExpression;
+    readonly _ZERO: BoxedExpression;
     /** @internal */
-    readonly ONE: BoxedExpression;
+    readonly _ONE: BoxedExpression;
     /** @internal */
-    readonly TWO: BoxedExpression;
+    readonly _TWO: BoxedExpression;
     /** @internal */
-    readonly HALF: BoxedExpression;
+    readonly _HALF: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly _NEGATIVE_ONE: BoxedExpression;
     /** @internal */
-    readonly I: BoxedExpression;
+    readonly _I: BoxedExpression;
     /** @internal */
-    readonly NAN: BoxedExpression;
+    readonly _NAN: BoxedExpression;
     /** @internal */
-    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly _POSITIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly _NEGATIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly COMPLEX_INFINITY: BoxedExpression;
+    readonly _COMPLEX_INFINITY: BoxedExpression;
     /** @internal */
-    readonly DECIMAL_NAN: Decimal;
+    readonly _DECIMAL_NAN: Decimal;
     /** @internal */
-    readonly DECIMAL_ZERO: Decimal;
+    readonly _DECIMAL_ZERO: Decimal;
     /** @internal */
-    readonly DECIMAL_ONE: Decimal;
+    readonly _DECIMAL_ONE: Decimal;
     /** @internal */
-    readonly DECIMAL_TWO: Decimal;
+    readonly _DECIMAL_TWO: Decimal;
     /** @internal */
-    readonly DECIMAL_HALF: Decimal;
+    readonly _DECIMAL_HALF: Decimal;
     /** @internal */
-    readonly DECIMAL_PI: Decimal;
+    readonly _DECIMAL_PI: Decimal;
     /** @internal */
-    readonly DECIMAL_NEGATIVE_ONE: Decimal;
+    readonly _DECIMAL_NEGATIVE_ONE: Decimal;
     /** The current scope */
-    context: RuntimeScope;
+    context: RuntimeScope | null;
     /** Absolute time beyond which evaluation should not proceed
      * @internal
      */
@@ -1427,7 +1462,7 @@ export interface IComputeEngine {
     readonly iterationLimit: number;
     /** @experimental */
     readonly recursionLimit: number;
-    defaultDomain: null | BoxedExpression;
+    defaultDomain: null | BoxedDomain;
     /** {@inheritDoc  NumericMode} */
     numericMode: NumericMode;
     tolerance: number;
@@ -1448,13 +1483,17 @@ export interface IComputeEngine {
      * If a definition existed previously, it is replaced.
      */
     defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
-    getSymbolDefinition(name: string, wikidata?: string): undefined | BoxedSymbolDefinition;
     /**
-     * Return `undefined` if no definition exist for this `head.
+     * Associate a new definition to a function in the current context.
+     *
+     * If a definition existed previously, it is replaced.
      */
-    getFunctionDefinition(head: string, wikidata?: string): undefined | BoxedFunctionDefinition;
+    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
+    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
+    /** Return `undefined` if no definition exist for this `head` */
+    lookupFunction(head: string, scope?: RuntimeScope): undefined | BoxedFunctionDefinition;
     /**
-     * Returned a boxed expression from the input.
+     * Return a boxed expression from the input.
      *
      * The result may not be canonical.
      */
@@ -1465,14 +1504,22 @@ export interface IComputeEngine {
     symbol(sym: string, metadata?: Metadata): BoxedExpression;
     /** Return a canonical boxed string */
     string(s: string, metadata?: Metadata): BoxedExpression;
-    /** Return a canonical boxed domain */
-    domain(domain: BoxedExpression | string, metadata?: Metadata): BoxedExpression;
-    /** Return a canonical expression.
+    /** Return a canonical boxed domain.
+     *
+     * If the domain is invalid, may return an `["Error"]` expression
+     *
+     */
+    domain(domain: SemiBoxedExpression | BoxedDomain | string, metadata?: Metadata): BoxedDomain;
+    /** Return a canonical lambda expression */
+    lambda(expr: SemiBoxedExpression, sig: BoxedDomain): BoxedLambdaExpression;
+    /**
+     * Return a canonical expression.
      *
      * Note that the result may not be a function, or may have a different
      * `head` than the one specified.
      *
-     * For example `ce.fn("Add", [ce.number(2),  ce.number(3)]))` \( \to \) 5
+     * For example:
+     * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
      *
      */
     fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
@@ -1483,15 +1530,15 @@ export interface IComputeEngine {
      * In general, consider using `fn()` or `box()` instead.
      *
      * The result is canonical, but the caller has to ensure that all the
-     * conditions are met (i.e. ops properly normalized and sorted, all
-     * ops canonical, etc..) so that the result is actually canonical.
+     * conditions are met (i.e. `ops` properly normalized and sorted, all
+     * `ops` canonical, etc..) so that the result is actually canonical.
      */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Error"...)`.
      *
      * The result is canonical.
      */
-    error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): any;
+    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     /** Shortcut for `this.fn("Add"...)`.
      *
      * The result is canonical.
@@ -1548,7 +1595,7 @@ export interface IComputeEngine {
      */
     serialize(expr: SemiBoxedExpression): LatexString;
     /**
-     * Options to control the serailization of MathJSON expression to LaTeX
+     * Options to control the serialization of MathJSON expression to LaTeX
      * when using `this.latex` or `this.engine.serialize()`.
      *
      *
@@ -1577,7 +1624,7 @@ export interface IComputeEngine {
      *
      *
      */
-    assume(symbol: LatexString | SemiBoxedExpression, domain: BoxedExpression): AssumeResult;
+    assume(symbol: LatexString | SemiBoxedExpression, domain: BoxedDomain): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     assume(arg1: LatexString | SemiBoxedExpression, arg2?: BoxedExpression): AssumeResult;
     /** Remove all assumptions about one or more symbols */
@@ -1585,7 +1632,7 @@ export interface IComputeEngine {
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
     pushScope(options?: {
-        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
         assumptions?: (LatexString | Expression | BoxedExpression)[];
         scope?: Partial<Scope>;
     }): void;
@@ -1608,10 +1655,9 @@ export interface IComputeEngine {
     cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
     readonly stats: ComputeEngineStats;
     /** @internal */
-    purge(): void;
+    reset(): void;
     /** @internal */
     _register(expr: BoxedExpression): void;
     /** @internal */
     _unregister(expr: BoxedExpression): void;
 }
-export declare function getVars(expr: BoxedExpression): string[];