consys/dsl/Expression.d.ts

consys is a flexible tool to evaluate models using generic and readable constraints.

import Token from './Token';
export declare namespace Expression {
    type Statistics = {
        counts: {
            model: {
                [key: string]: number;
            };
            state: {
                [key: string]: number;
            };
        };
    };
    /**
     * Represents the root node of an abstract syntax tree that was created from a given source.
     */
    class AST {
        readonly root: Expression.Expression | null;
        readonly source: string;
        readonly statistics: Statistics;
        constructor(root: Expression.Expression | null, source: string, statistics: Statistics);
        toString(): string;
    }
    /**
     * Implementations of this interface can use these methods to traverse the ast.
     */
    interface Visitor<T> {
        visitBinaryExpression(expression: Expression.Binary): T;
        visitConstraintExpression(expression: Expression.Constraint): T;
        visitFunctionExpression(expression: Expression.Function): T;
        visitGroupingExpression(expression: Expression.Grouping): T;
        visitLiteralExpression(expression: Expression.Literal): T;
        visitLogicalExpression(expression: Expression.Logical): T;
        visitUnaryExpression(expression: Expression.Unary): T;
        visitVariableExpression(expression: Expression.Variable): T;
    }
    interface Expression {
        accept<T>(visitor: Visitor<T>): T;
    }
    class Binary implements Expression {
        readonly left: Expression;
        readonly operator: Token;
        readonly right: Expression;
        constructor(left: Expression, operator: Token, right: Expression);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Constraint implements Expression {
        readonly activation: Expression;
        readonly assertion: Expression;
        constructor(activation: Expression, assertion: Expression);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Function implements Expression {
        readonly name: Token;
        readonly args: Expression[];
        constructor(name: Token, args: Expression[]);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Grouping implements Expression {
        readonly expression: Expression;
        constructor(expression: Expression);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Literal implements Expression {
        readonly value: Token;
        constructor(value: Token);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Logical implements Expression {
        readonly left: Expression;
        readonly operator: Token;
        readonly right: Expression;
        constructor(left: Expression, operator: Token, right: Expression);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Unary implements Expression {
        readonly operator: Token;
        readonly right: Expression;
        constructor(operator: Token, right: Expression);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
    class Variable implements Expression {
        readonly prefix: Token;
        readonly name: Token[];
        constructor(prefix: Token, name: Token[]);
        accept<T>(visitor: Expression.Visitor<T>): T;
    }
}