@cortex-js/compute-engine 0.32.0 → 0.32.1

package/dist/types/common/type/ast-nodes.d.ts

@@ -0,0 +1,146 @@
+/* 0.32.1 */
+    kind: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export interface NamedElementNode extends ASTNode {
+    kind: 'named_element';
+    name?: string;
+    type: TypeNode;
+}
+export interface ArgumentNode extends ASTNode {
+    kind: 'argument';
+    element: NamedElementNode;
+    modifier?: 'optional' | 'variadic_zero' | 'variadic_one';
+}
+export interface FunctionSignatureNode extends ASTNode {
+    kind: 'function_signature';
+    arguments: ArgumentNode[];
+    returnType: TypeNode;
+}
+export interface UnionTypeNode extends ASTNode {
+    kind: 'union';
+    types: TypeNode[];
+}
+export interface IntersectionTypeNode extends ASTNode {
+    kind: 'intersection';
+    types: TypeNode[];
+}
+export interface NegationTypeNode extends ASTNode {
+    kind: 'negation';
+    type: TypeNode;
+}
+export interface GroupTypeNode extends ASTNode {
+    kind: 'group';
+    type: TypeNode;
+}
+export interface ListTypeNode extends ASTNode {
+    kind: 'list';
+    elementType: TypeNode;
+    dimensions?: DimensionNode[];
+}
+export interface VectorTypeNode extends ASTNode {
+    kind: 'vector';
+    elementType: TypeNode;
+    size?: number;
+}
+export interface MatrixTypeNode extends ASTNode {
+    kind: 'matrix';
+    elementType: TypeNode;
+    dimensions?: DimensionNode[];
+}
+export interface TensorTypeNode extends ASTNode {
+    kind: 'tensor';
+    elementType: TypeNode;
+}
+export interface TupleTypeNode extends ASTNode {
+    kind: 'tuple';
+    elements: NamedElementNode[];
+}
+export interface RecordTypeNode extends ASTNode {
+    kind: 'record';
+    entries: RecordEntryNode[];
+}
+export interface RecordEntryNode extends ASTNode {
+    kind: 'record_entry';
+    key: string;
+    valueType: TypeNode;
+}
+export interface DictionaryTypeNode extends ASTNode {
+    kind: 'dictionary';
+    valueType: TypeNode;
+}
+export interface SetTypeNode extends ASTNode {
+    kind: 'set';
+    elementType: TypeNode;
+}
+export interface CollectionTypeNode extends ASTNode {
+    kind: 'collection';
+    elementType: TypeNode;
+    indexed?: boolean;
+}
+export interface ExpressionTypeNode extends ASTNode {
+    kind: 'expression';
+    operator: string;
+}
+export interface SymbolTypeNode extends ASTNode {
+    kind: 'symbol';
+    name: string;
+}
+export interface NumericTypeNode extends ASTNode {
+    kind: 'numeric';
+    baseType: string;
+    lowerBound?: ValueNode;
+    upperBound?: ValueNode;
+}
+export interface PrimitiveTypeNode extends ASTNode {
+    kind: 'primitive';
+    name: string;
+}
+export interface TypeReferenceNode extends ASTNode {
+    kind: 'type_reference';
+    name: string;
+    isForward?: boolean;
+}
+export interface ValueNode extends ASTNode {
+    kind: 'value';
+    value: any;
+    valueType: 'string' | 'number' | 'boolean' | 'infinity' | 'nan';
+}
+export interface DimensionNode extends ASTNode {
+    kind: 'dimension';
+    size: number | null;
+}
+export interface IdentifierNode extends ASTNode {
+    kind: 'identifier';
+    name: string;
+}
+export interface VerbatimStringNode extends ASTNode {
+    kind: 'verbatim_string';
+    value: string;
+}
+export type TypeNode = FunctionSignatureNode | UnionTypeNode | IntersectionTypeNode | NegationTypeNode | GroupTypeNode | ListTypeNode | VectorTypeNode | MatrixTypeNode | TensorTypeNode | TupleTypeNode | RecordTypeNode | DictionaryTypeNode | SetTypeNode | CollectionTypeNode | ExpressionTypeNode | SymbolTypeNode | NumericTypeNode | PrimitiveTypeNode | TypeReferenceNode | ValueNode;
+export interface ASTVisitor<T> {
+    visitFunctionSignature(node: FunctionSignatureNode): T;
+    visitUnionType(node: UnionTypeNode): T;
+    visitIntersectionType(node: IntersectionTypeNode): T;
+    visitNegationType(node: NegationTypeNode): T;
+    visitGroupType(node: GroupTypeNode): T;
+    visitListType(node: ListTypeNode): T;
+    visitVectorType(node: VectorTypeNode): T;
+    visitMatrixType(node: MatrixTypeNode): T;
+    visitTensorType(node: TensorTypeNode): T;
+    visitTupleType(node: TupleTypeNode): T;
+    visitRecordType(node: RecordTypeNode): T;
+    visitDictionaryType(node: DictionaryTypeNode): T;
+    visitSetType(node: SetTypeNode): T;
+    visitCollectionType(node: CollectionTypeNode): T;
+    visitExpressionType(node: ExpressionTypeNode): T;
+    visitSymbolType(node: SymbolTypeNode): T;
+    visitNumericType(node: NumericTypeNode): T;
+    visitPrimitiveType(node: PrimitiveTypeNode): T;
+    visitTypeReference(node: TypeReferenceNode): T;
+    visitValue(node: ValueNode): T;
+}
+export declare function visitNode<T>(node: TypeNode, visitor: ASTVisitor<T>): T;

package/dist/types/common/type/boxed-type.d.ts

@@ -0,0 +1,30 @@
+/* 0.32.1 */
+/** @category Type */
+export declare class BoxedType {
+    static unknown: BoxedType;
+    static number: BoxedType;
+    static non_finite_number: BoxedType;
+    static finite_number: BoxedType;
+    static finite_integer: BoxedType;
+    static finite_real: BoxedType;
+    static string: BoxedType;
+    static dictionary: BoxedType;
+    static setNumber: BoxedType;
+    static setComplex: BoxedType;
+    static setImaginary: BoxedType;
+    static setReal: BoxedType;
+    static setRational: BoxedType;
+    static setFiniteInteger: BoxedType;
+    static setInteger: BoxedType;
+    type: Type;
+    static widen(...types: ReadonlyArray<BoxedType | Type>): BoxedType;
+    static narrow(...types: ReadonlyArray<BoxedType | Type>): BoxedType;
+    constructor(type: Type | TypeString, typeResolver?: TypeResolver);
+    matches(other: Type | BoxedType): boolean;
+    is(other: Type): boolean;
+    get isUnknown(): boolean;
+    toString(): string;
+    toJSON(): string;
+    [Symbol.toPrimitive](hint: string): string | null;
+    valueOf(): string;
+}

package/dist/types/common/type/lexer.d.ts

@@ -0,0 +1,51 @@
+/* 0.32.1 */
+export interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export interface LexerError {
+    message: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export declare class Lexer {
+    input: string;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    constructor(input: string);
+    saveState(): {
+        pos: number;
+        line: number;
+        column: number;
+        tokens: Token[];
+    };
+    restoreState(state: {
+        pos: number;
+        line: number;
+        column: number;
+        tokens: Token[];
+    }): void;
+    error(message: string): never;
+    private peek;
+    private advance;
+    private match;
+    private isEOF;
+    private skipWhitespace;
+    private readIdentifier;
+    private readVerbatimString;
+    private readStringLiteral;
+    private readNumber;
+    private createToken;
+    private nextToken;
+    tokenize(): Token[];
+    peekToken(): Token;
+    consumeToken(): Token;
+    matchToken(type: TokenType): boolean;
+    expectToken(type: TokenType): Token;
+}

package/dist/types/common/type/parse.d.ts

@@ -0,0 +1,211 @@
+/* 0.32.1 */
+/**
+ * BNF grammar for the type parser:
+ *
+<type> ::= <union_type>
+         | <function_signature>
+
+<union_type> ::= <intersection_type> ( " | " <intersection_type> )*
+
+<intersection_type> ::= <primary_type_with_negation> ( " & " <primary_type_with_negation> )*
+
+<primary_type_with_negation> ::= ( "!" )? <primary_type>
+
+<primary_type> ::= <group>
+                 | <list_type>
+                 | <tuple_type>
+                 | <record_type>
+                 | <dictionary_type>
+                 | <set_type>
+                 | <collection_type>
+                 | <expression_type>
+                 | <symbol_type>
+                 | <numeric_type>
+                 | <primitive_type>
+                 | <value>
+                 | <type_reference>
+
+<group> ::= "(" <type> ")"
+
+(* --- Function Signatures --- *)
+
+<function_signature> ::= <arguments> " -> " <type>
+
+<arguments> ::= "()"
+              | "(" <argument_list>? ")"
+
+(* Note: The parser enforces a semantic rule: required arguments must come before optional and variadic arguments. *)
+<argument_list> ::= <argument_specifier> ( "," <argument_specifier> )*
+
+<argument_specifier> ::= <named_element> ( "?" | "*" | "+" )?
+
+<named_element> ::= ( <name> ":" )? <type>
+
+<name> ::= <identifier> | <verbatim_string>
+
+
+(* --- Collection-like Types --- *)
+
+<list_type> ::= "list" ( "<" <type> ( "^" <dimensions> )? ">" )?
+              | "vector" ( "<" ( <type> ("^" <dimension_specifier>)? | <dimensions> ) ">" )?
+              | "matrix" ( "<" ( <type> ("^" <dimensions>)? | <dimensions> ) ">" )?
+              | "tensor" ( "<" <type> ">" )?
+
+<dimensions> ::= <dimension_specifier> ( "x" <dimension_specifier> )*
+               | "(" <dimension_specifier> ( "x" <dimension_specifier> )* ")"
+
+<dimension_specifier> ::= <positive_integer_literal> | "?"
+
+<tuple_type> ::= "tuple<" ( <named_element> ( "," <named_element> )* )? ">"
+
+<record_type> ::= "record"
+                | "record<" <record_element> ( "," <record_element> )* ">"
+
+<record_element> ::= <key> ":" <type>
+
+<key> ::= <identifier> | <verbatim_string>
+
+<dictionary_type> ::= "dictionary"
+                    | "dictionary<" <type> ">"
+
+<set_type> ::= "set"
+             | "set<" <type> ">"
+
+<collection_type> ::= ( "collection" | "indexed_collection" ) ( "<" <type> ">" )?
+
+
+(* --- Other Constructed Types --- *)
+
+<expression_type> ::= "expression<" <identifier> ">"
+
+<symbol_type> ::= "symbol<" <identifier> ">"
+
+<numeric_type> ::= <numeric_primitive> "<" <bound> ".." <bound> ">"
+
+<bound> ::= <number_literal> | "-oo" | "oo" | ""
+
+
+(* --- Atomic and Primitive Types --- *)
+
+<type_reference> ::= ( "type" )? <identifier>
+
+<value> ::= <string_literal>
+          | <number_literal>
+          | "true" | "false"
+          | "nan" | "infinity" | "+infinity" | "oo" | "∞" | "+oo" | "+∞"
+          | "-infinity" | "-oo" | "-∞"
+
+<primitive_type> ::= <numeric_primitive>
+                   | "any" | "unknown" | "nothing" | "never" | "error"
+                   | "expression" | "symbol" | "function" | "value"
+                   | "scalar" | "boolean" | "string"
+                   | "collection" | "indexed_collection" | "list" | "tuple"
+                   | "set" | "record" | "dictionary"
+
+<numeric_primitive> ::= "number" | "finite_number" | "complex" | "finite_complex"
+                      | "imaginary" | "real" | "finite_real" | "rational"
+                      | "finite_rational" | "integer" | "finite_integer"
+                      | "non_finite_number"
+
+
+(* --- Terminals (Lexical Tokens) --- *)
+
+<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
+
+<verbatim_string> ::= "`" ( [^`] | "\`" | "\\" )* "`"
+
+<positive_integer_literal> ::= [1-9][0-9]*
+
+<number_literal> ::= (* As parsed by the valueParser, including integers, decimals, and scientific notation *)
+
+<string_literal> ::= '"' ( [^"] | '\"' )* '"'
+ *
+ */
+declare class TypeParser {
+    buffer: string;
+    pos: number;
+    _valueParser: (parser: TypeParser) => any;
+    _typeResolver: TypeResolver;
+    constructor(buffer: string, options?: {
+        valueParser?: (parser: TypeParser) => any;
+        typeResolver?: TypeResolver;
+    });
+    error(...messages: (string | undefined)[]): never;
+    peek(): string;
+    consume(): string;
+    /** Check if the upcoming tokens match s, return false if not, consume otherwise */
+    match(s: string): boolean;
+    /** If the next token don't match `>`, error */
+    expectClosingBracket(): void;
+    /** If a white space is allowed, call before `consume()` or `match()` */
+    skipWhitespace(): void;
+    isEOF(): boolean;
+    parseValue(): Type | null;
+    parseTypeReference(): TypeReference | null;
+    parsePrimitiveType(): Type | null;
+    /**
+     * Arguments are `name: type` or `type` separated by commas.
+     * Arguments can be optional, i.e. `name: type?` or `type?`.
+     * Variadic arguments are `name: type+`, `type+`, `name: type*` or `type*`.
+     */
+    parseArguments(): [
+        required: NamedElement[],
+        optional: NamedElement[],
+        variadic: NamedElement | undefined,
+        variadicMin: 0 | 1 | undefined
+    ];
+    parseFunctionSignature(): Type | null;
+    parsePositiveIntegerLiteral(): number | null;
+    parseOptionalDimension(): number | null;
+    parseDimensions(): number[] | undefined;
+    parseList(): Type | null;
+    /**
+     * Parse the name of a named element, i.e. an identifier followed by a colon.
+     * Does special error handling for optional qualifiers.
+     * */
+    parseName(): string | null;
+    parseVerbatimString(): string | null;
+    /**
+     * A general purpose identifier, used for expresion<>, symbol<>, type references, record keys, etc.
+     *
+     * Not used for arguments (they have special error handling with `parseName()`).
+     */
+    parseIdentifier(): string | null;
+    /** Parse:
+     * - "<identifier>: <type>"
+     * - "<type>"
+     *
+     * Does not parse variadic arguments, i.e. `type+` or `name: type+`.
+     */
+    parseNamedElement(): NamedElement | null;
+    parseTupleElements(): NamedElement[];
+    parseTuple(): Type | null;
+    /** Parse a non-optional group, i.e. "(" <type> ")" */
+    parseGroup(): Type | null;
+    parseSet(): Type | null;
+    parseRecordKeyValue(): [string, Type][];
+    parseRecord(): Type | null;
+    parseDictionary(): Type | null;
+    parseCollection(): Type | null;
+    parseExpression(): Type | null;
+    parseSymbol(): Type | null;
+    /** Parse a constructed numeric type with a range */
+    parseNumericType(): Type | null;
+    parseStringType(): Type | null;
+    parsePrimary(): Type;
+    parseUnexpectedToken(): string | undefined;
+    parseMaybePrimary(): Type | null;
+    parseNegationType(): Type | null;
+    parseIntersectionType(): Type | null;
+    parseUnionType(): Type | null;
+    parseType(): Readonly<Type> | null;
+    /** Parse a type, but return null if there's a problem instead
+     * of throwing.
+     */
+    parseTypeMaybe(): Readonly<Type> | null;
+    parse(): Readonly<Type>;
+}
+export declare function parseType(s: undefined, typeResolver?: TypeResolver): undefined;
+export declare function parseType(s: TypeString | Type, typeResolver?: TypeResolver): Type;
+export declare function parseType(s: TypeString | Type | undefined, typeResolver?: TypeResolver): Type | undefined;
+export { TypeParser };

package/dist/types/common/type/parser.d.ts

@@ -0,0 +1,45 @@
+/* 0.32.1 */
+import { TypeNode } from './ast-nodes';
+import { TypeResolver } from './types';
+export declare class Parser {
+    private lexer;
+    private typeResolver;
+    private current;
+    constructor(input: string, options?: {
+        typeResolver?: TypeResolver;
+    });
+    error(message: string, suggestion?: string): never;
+    errorAtToken(token: Token, message: string, suggestion?: string): never;
+    private advance;
+    private match;
+    private expect;
+    private createNode;
+    parseType(): TypeNode;
+    private checkForNakedFunctionSignature;
+    private parseUnionType;
+    private parseIntersectionType;
+    private parsePrimaryType;
+    private parseFunctionSignature;
+    private parseArgument;
+    private parseNamedElement;
+    private parseListType;
+    private parseListTypeImpl;
+    private parseVectorType;
+    private parseMatrixType;
+    private parseTensorType;
+    private parseDimensions;
+    private parseDimension;
+    private parseDimensionWithX;
+    private parseTupleType;
+    private parseRecordType;
+    private parseRecordEntry;
+    private parseDictionaryType;
+    private parseSetType;
+    private parseCollectionType;
+    private parseExpressionType;
+    private parseSymbolType;
+    private parseNumericType;
+    private parsePrimitiveType;
+    private parseValue;
+    private parseTypeReference;
+}

package/dist/types/common/type/primitive.d.ts

@@ -0,0 +1,10 @@
+/* 0.32.1 */
+/** All the types representing numeric values */
+export declare const NUMERIC_TYPES: NumericPrimitiveType[];
+export declare const INDEXED_COLLECTION_TYPES: PrimitiveType[];
+export declare const COLLECTION_TYPES: PrimitiveType[];
+export declare const SCALAR_TYPES: PrimitiveType[];
+export declare const VALUE_TYPES: PrimitiveType[];
+export declare const EXPRESSION_TYPES: PrimitiveType[];
+export declare const PRIMITIVE_TYPES: PrimitiveType[];
+export declare function isValidPrimitiveType(s: any): s is PrimitiveType;

package/dist/types/common/type/serialize.d.ts

@@ -0,0 +1,2 @@
+/* 0.32.1 */
+export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -0,0 +1,6 @@
+/* 0.32.1 */
+/** Return true if lhs is a subtype of rhs */
+export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
+/** Return true if lhs is a subtype of rhs */
+export declare function isSubtype(lhs: Type | TypeString, rhs: Type | TypeString): boolean;
+export declare function isCompatible(lhs: PrimitiveType, rhs: PrimitiveType, compatibility: TypeCompatibility): boolean;

package/dist/types/common/type/type-builder.d.ts

@@ -0,0 +1,32 @@
+/* 0.32.1 */
+import { Type, TypeResolver } from './types';
+export declare class TypeBuilder implements ASTVisitor<Type> {
+    private typeResolver;
+    constructor(typeResolver?: TypeResolver);
+    buildType(node: TypeNode): Type;
+    visitFunctionSignature(node: FunctionSignatureNode): Type;
+    visitUnionType(node: UnionTypeNode): Type;
+    visitIntersectionType(node: IntersectionTypeNode): Type;
+    visitNegationType(node: NegationTypeNode): Type;
+    visitGroupType(node: GroupTypeNode): Type;
+    visitListType(node: ListTypeNode): Type;
+    visitVectorType(node: VectorTypeNode): Type;
+    visitMatrixType(node: MatrixTypeNode): Type;
+    visitTensorType(node: TensorTypeNode): Type;
+    visitTupleType(node: TupleTypeNode): Type;
+    visitRecordType(node: RecordTypeNode): Type;
+    visitDictionaryType(node: DictionaryTypeNode): Type;
+    visitSetType(node: SetTypeNode): Type;
+    visitCollectionType(node: CollectionTypeNode): Type;
+    visitExpressionType(node: ExpressionTypeNode): Type;
+    visitSymbolType(node: SymbolTypeNode): Type;
+    visitNumericType(node: NumericTypeNode): Type;
+    visitPrimitiveType(node: PrimitiveTypeNode): Type;
+    visitTypeReference(node: TypeReferenceNode): Type;
+    visitValue(node: ValueNode): Type;
+    private buildNamedElement;
+    private buildDimension;
+    private buildValue;
+    private isAnyType;
+}
+export declare function buildTypeFromAST(node: TypeNode, typeResolver?: TypeResolver): Type;