@runtimeverificationinc/tsk/dist/types/kast/inner.d.ts

TypeScript/JavaScript library for K Framework functionality

import { KAst } from "./kast";
export declare class KSort extends KAst {
    /**
     * Store a simple sort name.
     */
    readonly name: string;
    constructor(name: string);
    static fromDict(d: Record<string, any>): KSort;
    toDict(useIteration?: boolean): Record<string, any>;
    let(name?: string | null): KSort;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KLabel extends KAst {
    /**
     * Represents a symbol that can be applied in a K AST, potentially with sort parameters.
     */
    readonly name: string;
    readonly params: KSort[];
    constructor(name: string, ...args: any[]);
    static fromDict(d: Record<string, any>): KLabel;
    toDict(useIteration?: boolean): Record<string, any>;
    let(options?: {
        name?: string;
        params?: (string | KSort)[];
    }): KLabel;
    apply(...args: KInner[]): KApply;
    protected fieldEquals(other: KAst): boolean;
}
export declare abstract class KInner extends KAst {
    private static readonly NODES;
    static fromJson(s: string, useIteration?: boolean): KInner;
    private static _fromDictRecursive;
    static fromDict(dct: Record<string, any>, useIteration?: boolean): KInner;
    abstract get terms(): KInner[];
    abstract letTerms(terms: KInner[]): KInner;
    abstract match(term: KInner): Subst | null;
    abstract _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    mapInner(f: (term: KInner) => KInner): KInner;
    private _toDictRecursive;
    toDict(useIteration?: boolean): Record<string, any>;
    protected static combineMatches(substs: (Subst | null)[]): Subst | null;
}
export declare class KToken extends KInner {
    readonly token: string;
    readonly sort: KSort;
    constructor(token: string, sort: string | KSort);
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KToken;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        token?: string;
        sort?: string | KSort;
    }): KToken;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KToken;
    match(term: KInner): Subst | null;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KVariable extends KInner {
    readonly name: string;
    readonly sort: KSort | null;
    constructor(name: string, sort?: string | KSort | null);
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KVariable;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        name?: string;
        sort?: string | KSort | null;
    }): KVariable;
    letSort(sort: KSort | null): KVariable;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KVariable;
    match(term: KInner): Subst;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KApply extends KInner {
    readonly label: KLabel;
    readonly args: KInner[];
    constructor(label: string | KLabel, ...args: any[]);
    get arity(): number;
    get isCell(): boolean;
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KApply;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        label?: string | KLabel;
        args?: KInner[];
    }): KApply;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KApply;
    match(term: KInner): Subst | null;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KAs extends KInner {
    readonly pattern: KInner;
    readonly alias: KInner;
    constructor(pattern: KInner, alias: KInner);
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KAs;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        pattern?: KInner;
        alias?: KInner;
    }): KAs;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KAs;
    match(term: KInner): Subst | null;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KRewrite extends KInner {
    readonly lhs: KInner;
    readonly rhs: KInner;
    constructor(lhs: KInner, rhs: KInner);
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KRewrite;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        lhs?: KInner;
        rhs?: KInner;
    }): KRewrite;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KRewrite;
    match(term: KInner): Subst | null;
    applyTop(term: KInner): KInner;
    apply(term: KInner): KInner;
    replaceTop(term: KInner): KInner;
    replace(term: KInner): KInner;
    protected fieldEquals(other: KAst): boolean;
}
export declare class KSequence extends KInner {
    readonly items: KInner[];
    constructor(...args: any[]);
    get arity(): number;
    static _fromDict(dct: Record<string, any>, terms: KInner[]): KSequence;
    _toDict(terms: Record<string, any>[], useIteration?: boolean): Record<string, any>;
    let(options?: {
        items?: KInner[];
    }): KSequence;
    get terms(): KInner[];
    letTerms(terms: KInner[]): KSequence;
    match(term: KInner): Subst | null;
    protected fieldEquals(other: KAst): boolean;
}
export declare class Subst {
    private readonly _subst;
    constructor(subst?: Map<string, KInner> | Record<string, KInner>);
    get(key: string): KInner | undefined;
    has(key: string): boolean;
    keys(): string[];
    values(): KInner[];
    entries(): [string, KInner][];
    get size(): number;
    static fromDict(d: Record<string, any>, useIteration?: boolean): Subst;
    toDict(useIteration?: boolean): Record<string, any>;
    union(other: Subst): Subst | null;
    apply(term: KInner): KInner;
    private termsEqual;
    unapply(term: KInner): KInner;
    static from_pred(pred: KInner): Subst;
    compose(other: Subst): Subst;
    minimize(): Subst;
}
export declare function bottomUpWithSummary<A>(f: (term: KInner, summaries: A[]) => [KInner, A], kinner: KInner): [KInner, A];
export declare function bottomUp(f: (term: KInner) => KInner, kinner: KInner): KInner;
export declare function bottomUpAsync(f: (term: KInner) => KInner, kinner: KInner, yieldFrequency?: number): Promise<KInner>;
export declare function topDown(f: (term: KInner) => KInner, term: KInner): KInner;
/**
 * Async version of topDown that yields control periodically to prevent blocking the main thread.
 */
export declare function topDownAsync(f: (term: KInner) => KInner, term: KInner, yieldFrequency?: number): Promise<KInner>;
export declare function varOccurrences(term: KInner): Record<string, KVariable[]>;
export declare function keepVarsSorted(occurrences: Record<string, KVariable[]>): Record<string, KVariable>;
export declare function collect(callback: (term: KInner) => void, term: KInner): void;
export declare function buildAssoc(unit: KInner, label: string | KLabel, terms: Iterable<KInner>): KInner;
export declare function buildCons(unit: KInner, label: string | KLabel, terms: Iterable<KInner>): KInner;
export declare function flattenLabel(label: string, kast: KInner): KInner[];