@dallaylaen/ski-interpreter 2.3.2 → 2.4.0

package/{types/src → lib/types}/expr.d.ts

@@ -1,39 +1,79 @@
-export type TraverseValue<T_1> = T_1 | TraverseControl<T_1> | null;
-export type Partial = Expr | ((arg0: Expr) => Partial);
+import { TraverseValue, Dict } from './internal';
 /**
- * : boolean,      // whether the irreducible form is only contains its arguments. implies normal.
- *   arity?: number,       // the number of arguments that is sufficient to reach the normal form
- *                         // absent unless normal.
- *   discard?: boolean,    // whether the term (or subterms, unless proper) can discard arguments.
- *   duplicate?: boolean,  // whether the term (or subterms, unless proper) can duplicate arguments.
- *   skip?: Set<number>,   // indices of arguments that are discarded. nonempty inplies discard.
- *   dup?: Set<number>,    // indices of arguments that are duplicated. nonempty implies duplicate.
- *   expr?: Expr,          // canonical form containing lambdas, applications, and variables, if any
- *   steps?: number,       // number of steps taken to obtain the aforementioned information, if applicable
- * }} TermInfo
+ * @desc Control primitives for fold() and traverse() methods.
  */
-export type proper = {
-    normal: boolean;
+export declare const control: {
+    descend: <T>(value: T) => import("./internal").TraverseControl<T>;
+    prune: <T>(value: T) => import("./internal").TraverseControl<T>;
+    redo: <T>(value: T) => import("./internal").TraverseControl<T>;
+    stop: <T>(value: T) => import("./internal").TraverseControl<T>;
 };
 /**
- * @typedef {Expr | function(Expr): Partial} Partial
- */
-/**
- * @typedef {{
- *   normal: boolean,      // whether the term becomes irreducible after receiving a number of arguments.
- *                         // if false, other properties may be missing.
- *   proper: boolean,      // whether the irreducible form is only contains its arguments. implies normal.
- *   arity?: number,       // the number of arguments that is sufficient to reach the normal form
- *                         // absent unless normal.
- *   discard?: boolean,    // whether the term (or subterms, unless proper) can discard arguments.
- *   duplicate?: boolean,  // whether the term (or subterms, unless proper) can duplicate arguments.
- *   skip?: Set<number>,   // indices of arguments that are discarded. nonempty inplies discard.
- *   dup?: Set<number>,    // indices of arguments that are duplicated. nonempty implies duplicate.
- *   expr?: Expr,          // canonical form containing lambdas, applications, and variables, if any
- *   steps?: number,       // number of steps taken to obtain the aforementioned information, if applicable
- * }} TermInfo
+ * @desc List of predefined native combinators.
+ * This is required for toSKI() to work, otherwise could as well have been in parser.js.
  */
-export class Expr {
+export declare const native: Dict<Native>;
+export type TermInfo = {
+    normal: boolean;
+    proper: boolean;
+    arity?: number;
+    discard?: boolean;
+    duplicate?: boolean;
+    skip?: Set<number>;
+    dup?: Set<number>;
+    expr?: Expr;
+    steps?: number;
+};
+export type Invocation = Expr | ((arg: Expr) => Invocation);
+export type Step = {
+    expr: Expr;
+    steps: number;
+    changed: boolean;
+};
+export type Run = {
+    expr: Expr;
+    steps: number;
+    final: boolean;
+};
+export type RunOptions = {
+    max?: number;
+    steps?: number;
+    throw?: boolean;
+};
+export type FormatOptions = {
+    terse?: boolean;
+    html?: boolean;
+    brackets?: [string, string];
+    space?: string;
+    var?: [string, string];
+    lambda?: [string, string, string];
+    around?: [string, string];
+    redex?: [string, string];
+    inventory?: Dict<Expr>;
+};
+type RefinedFormatOptions = {
+    terse?: boolean;
+    html?: boolean;
+    brackets: [string, string];
+    space: string;
+    var: [string, string];
+    lambda: [string, string, string];
+    around: [string, string];
+    redex: [string, string];
+    inventory?: Dict<Expr>;
+};
+type TraverseOptions = {
+    order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost';
+};
+type TraverseCallback = (e: Expr) => TraverseValue<Expr>;
+export declare class Expr {
+    static control: {
+        descend: <T>(value: T) => import("./internal").TraverseControl<T>;
+        prune: <T>(value: T) => import("./internal").TraverseControl<T>;
+        redo: <T>(value: T) => import("./internal").TraverseControl<T>;
+        stop: <T>(value: T) => import("./internal").TraverseControl<T>;
+    };
+    static native: Dict<Native>;
     /**
      *  @descr A combinatory logic expression.
      *
@@ -53,6 +93,15 @@ export class Expr {
      *                Typically only applicable to descendants of Named.
      * @property {TermInfo} [props] - properties inferred from the term's behavior
      */
+    context?: {
+        scope?: object;
+        env?: Dict<Expr>;
+        src?: string;
+        parser: object;
+    };
+    arity?: number;
+    note?: string;
+    props?: TermInfo;
     /**
      *
      * @desc Define properties of the term based on user supplied options and/or inference results.
@@ -67,28 +116,26 @@ export class Expr {
      * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true
      * @return {this}
      */
-    private _setup;
-    fancyName: any;
-    note: any;
-    arity: any;
-    props: TermInfo;
+    _setup(options?: {
+        note?: string;
+        arity?: number;
+        fancy?: string;
+        canonize?: boolean;
+        max?: number;
+        maxArgs?: number;
+    }): this;
     /**
      * @desc apply self to zero or more terms and return the resulting term,
      * without performing any calculations whatsoever
      * @param {Expr} args
      * @return {Expr}
      */
-    apply(...args: Expr): Expr;
+    apply(...args: Expr[]): Expr;
     /**
      * @desc Replace all aliases in the expression with their definitions, recursively.
      * @return {Expr}
      */
     expand(): Expr;
-    /**
-     * @desc Returns true if the expression contains only free variables and applications, false otherwise.
-     * @returns {boolean}
-     */
-    freeOnly(): boolean;
     /**
      * @desc Traverse the expression tree, applying change() to each node.
      *       If change() returns an Expr, the node is replaced with that value.
@@ -115,23 +162,21 @@ export class Expr {
      * @param {(e:Expr) => TraverseValue<Expr>} change
      * @returns {Expr|null}
      */
-    traverse(options?: {
-        order?: "LO" | "LI" | "leftmost-outermost" | "leftmost-innermost";
-    }, change: (e: Expr) => TraverseValue<Expr>): Expr | null;
+    traverse(options: TraverseOptions | TraverseCallback, change?: TraverseCallback): Expr | null;
     /**
      * @private
      * @param {Object} options
      * @param {(e:Expr) => TraverseValue<Expr>} change
      * @returns {TraverseValue<Expr>}
      */
-    private _traverse_redo;
+    _traverse_redo(options: TraverseOptions, change: TraverseCallback): TraverseValue<Expr>;
     /**
      * @private
      * @param {Object} options
      * @param {(e:Expr) => TraverseValue<Expr>} change
      * @returns {TraverseValue<Expr>}
      */
-    private _traverse_descend;
+    _traverse_descend(options: TraverseOptions, change: TraverseCallback): TraverseValue<Expr>;
     /**
      * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.
      *
@@ -158,20 +203,33 @@ export class Expr {
      * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine
      * @returns {T}
      */
-    fold<T_1>(initial: T_1, combine: (acc: T_1, expr: Expr) => TraverseValue<T_1>): T_1;
+    fold<T>(initial: T, combine: (acc: T, expr: Expr) => TraverseValue<T>): T;
+    _fold<T>(initial: T, combine: (acc: T, expr: Expr) => TraverseValue<T>): TraverseValue<T>;
     /**
+     * @experimental
+     * @desc  Fold an application tree bottom to top.
+     *        For each subtree, the function is given the term in the root position and
+     *        a list of the results of folding its arguments.
+     *
+     *        E.g. fold('x y (z t)', f) results in f(x, [f(y, []), f(z, [f(t, [])])])
+     *
+     * @example expr.foldBottomUp((head, tail) => {
+     *    if (head.arity && head.arity <= tail.length) {
+     *      return '(<span class="redex">'
+     *          + head + ' '
+     *          + tail.slice(0, head.arity).join(' ')
+     *          + '</span>'
+     *          + tail.slice(head.arity).join(' ')
+     *          + ')';
+     *    } else {
+     *       return '(' + head + ' ' + tail.join(' ') + ')';
+     *    }
+     * });
      * @template T
-     * @param {T} initial
-     * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine
-     * @returns {TraverseValue<T>}
-     * @private
+     * @param {(head: Expr, tail: T[]) => T} fun
+     * @return {T}
      */
-    private _fold;
-    /**
-     * @desc rough estimate of the term's complexity
-     * @return {number}
-     */
-    weight(): number;
+    foldBottomUp<T>(fun: (head: Expr, tail: T[]) => T): T;
     /**
      * @desc Try to empirically find an equivalent lambda term for the expression,
      *       returning also the term's arity and some other properties.
@@ -198,7 +256,11 @@ export class Expr {
      * @returns {TermInfo}
      * @private
      */
-    private _infer;
+    _infer(options: {
+        max: number;
+        maxArgs: number;
+        skipNames: Dict<boolean>;
+    }, nargs: number): TermInfo;
     /**
      * @desc Expand an expression into a list of terms
      * that give the initial expression when applied from left to right:
@@ -213,8 +275,7 @@ export class Expr {
     unroll(): Expr[];
     /**
      * @desc Returns a series of lambda terms equivalent to the given expression,
-     *       up to the provided computation steps limit,
-     *       in decreasing weight order.
+     *       up to the provided computation steps limit.
      *
      *       Unlike infer(), this method will always return something,
      *       even if the expression has no normal form.
@@ -229,21 +290,15 @@ export class Expr {
      *   html?: boolean,
      *   latin?: number,
      * }} options
-     * @param {number} [maxWeight] - maximum allowed weight of terms in the sequence
      * @return {IterableIterator<{expr: Expr, steps?: number, comment?: string}>}
      */
     toLambda(options?: {
         max?: number;
         maxArgs?: number;
-        varGen?: (arg0: void) => FreeVar;
-        steps?: number;
-        html?: boolean;
-        latin?: number;
-    }): IterableIterator<{
+    }): Generator<{
         expr: Expr;
-        steps?: number;
-        comment?: string;
-    }>;
+        steps: number;
+    }, void, unknown>;
     /**
      * @desc Rewrite the expression into S, K, and I combinators step by step.
      *     Returns an iterator yielding the intermediate expressions,
@@ -254,13 +309,11 @@ export class Expr {
      * @param {{max?: number}} [options]
      * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
      */
-    toSKI(options?: {
-        max?: number;
-    }): IterableIterator<{
-        final: boolean;
+    toSKI(_options?: {}): Generator<{
         expr: Expr;
         steps: number;
-    }>;
+        final: boolean;
+    }, void, unknown>;
     /**
      * Replace all instances of plug in the expression with value and return the resulting expression,
      * or null if no changes could be made.
@@ -292,16 +345,12 @@ export class Expr {
      * @param {Expr} arg
      * @returns {Partial | null}
      */
-    invoke(arg: Expr): Partial | null;
+    invoke(arg: Expr): Invocation | null;
     /**
      * @desc iterate one step of a calculation.
      * @return {{expr: Expr, steps: number, changed: boolean}}
      */
-    step(): {
-        expr: Expr;
-        steps: number;
-        changed: boolean;
-    };
+    step(): Step;
     /**
      * @desc Run uninterrupted sequence of step() applications
      *       until the expression is irreducible, or max number of steps is reached.
@@ -310,15 +359,7 @@ export class Expr {
      * @param {Expr} args
      * @return {{expr: Expr, steps: number, final: boolean}}
      */
-    run(opt?: {
-        max?: number;
-        steps?: number;
-        throw?: boolean;
-    } | Expr, ...args: Expr): {
-        expr: Expr;
-        steps: number;
-        final: boolean;
-    };
+    run(opt?: RunOptions | Expr, ...args: Expr[]): Run;
     /**
      * Execute step() while possible, yielding a brief description of events after each step.
      * Mnemonics: like run() but slower.
@@ -327,11 +368,7 @@ export class Expr {
      */
     walk(options?: {
         max?: number;
-    }): IterableIterator<{
-        final: boolean;
-        expr: Expr;
-        steps: number;
-    }>;
+    }): IterableIterator<Run>;
     /**
      * @desc True is the expressions are identical, false otherwise.
      *       Aliases are expanded.
@@ -375,7 +412,7 @@ export class Expr {
      * @param {Expr} actual
      * @param {string} comment
      */
-    expect(actual: Expr, comment?: string): void;
+    expect(actual: Expr | object, comment?: string): void;
     /**
      * @desc Returns string representation of the expression.
      *       Same as format() without options.
@@ -387,14 +424,14 @@ export class Expr {
      * @param {boolean} [first] - whether this is the first term in a sequence
      * @return {boolean}
      */
-    _braced(first?: boolean): boolean;
+    _braced(_first?: boolean): boolean;
     /**
      * @desc Whether the expression can be printed without a space when followed by arg.
      * @param {Expr} arg
      * @returns {boolean}
      * @private
      */
-    private _unspaced;
+    _unspaced(arg: Expr): boolean;
     /**
      * @desc    Stringify the expression with fancy formatting options.
      *          Said options mostly include wrappers around various constructs in form of ['(', ')'],
@@ -428,18 +465,7 @@ export class Expr {
      * @example foo.format({ inventory: { T } }) // use T as a named term, expand all others
      *
      */
-    format(options?: {
-        terse?: boolean;
-        html?: boolean;
-        brackets?: [string, string];
-        var?: [string, string];
-        lambda?: [string, string, string];
-        around?: [string, string];
-        redex?: [string, string];
-        inventory?: {
-            [x: string]: Expr;
-        };
-    }): string;
+    format(options?: FormatOptions): string;
     /**
      * @desc Internal method for format(), which performs the actual formatting.
      * @param {Object} options
@@ -447,7 +473,7 @@ export class Expr {
      * @returns {string}
      * @private
      */
-    private _format;
+    _format(options: RefinedFormatOptions, nargs: number): string;
     /**
      * @desc Returns a string representation of the expression tree, with indentation to show structure.
      *
@@ -474,55 +500,48 @@ export class Expr {
      * @desc Convert the expression to a JSON-serializable format.
      * @returns {string}
      */
-    toJSON(): string;
-}
-export namespace Expr {
-    export { native };
-    export { control };
-    export namespace extras {
-        export { toposort };
-    }
+    toJSON(): string | object;
 }
-export class App extends Expr {
+export declare class App extends Expr {
     /**
      * @desc Application of fun() to args.
      * Never ever use new App(fun, arg) directly, use fun.apply(...args) instead.
      * @param {Expr} fun
      * @param {Expr} arg
      */
-    constructor(fun: Expr, arg: Expr);
-    arg: Expr;
     fun: Expr;
-    _traverse_descend(options: any, change: any): any;
-    any(predicate: any): any;
-    _fold(initial: any, combine: any): any;
-    subst(search: any, replace: any): Expr;
+    arg: Expr;
+    final?: boolean;
+    constructor(fun: Expr, arg: Expr);
+    /** @property {boolean} [final] */
+    _traverse_descend(options: TraverseOptions, change: TraverseCallback): TraverseValue<Expr>;
+    any(predicate: (e: Expr) => boolean): boolean;
+    _fold<T>(initial: T, combine: (acc: T, expr: Expr) => TraverseValue<T>): TraverseValue<T>;
+    subst(search: Expr, replace: Expr): Expr | null;
     /**
      * @return {{expr: Expr, steps: number}}
      */
-    step(): {
-        expr: Expr;
-        steps: number;
-    };
-    invoke(arg: any): Partial;
-    final: boolean;
-    diff(other: any, swap?: boolean): string;
-    _braced(first: any): boolean;
-    _format(options: any, nargs: any): string;
-    _unspaced(arg: any): boolean;
+    step(): Step;
+    invoke(arg: Expr): Invocation | null;
+    unroll(): Expr[];
+    diff(other: Expr, swap?: boolean): string | null;
+    _braced(first?: boolean): boolean;
+    _format(options: RefinedFormatOptions, nargs: number): string;
+    _unspaced(arg: Expr): boolean;
 }
-export class Named extends Expr {
+export declare class Named extends Expr {
     /**
      * @desc An abstract class representing a term named 'name'.
      *
      * @param {String} name
      */
-    constructor(name: string);
     name: string;
-    _unspaced(arg: any): boolean;
-    _format(options: any, nargs: any): any;
+    fancyName?: string;
+    constructor(name: string);
+    _unspaced(arg: Expr): boolean;
+    _format(options: RefinedFormatOptions, nargs: number): string;
 }
-export class FreeVar extends Named {
+export declare class FreeVar extends Named {
     /**
      * @desc A named variable.
      *
@@ -540,16 +559,38 @@ export class FreeVar extends Named {
      * @param {string} name - name of the variable
      * @param {any} scope - an object representing where the variable belongs to.
      */
-    constructor(name: string, scope: any);
+    scope?: object;
     id: number;
-    scope: any;
-    diff(other: any, swap?: boolean): string;
-    subst(search: any, replace: any): any;
+    constructor(name: string, scope?: object);
+    diff(other: Expr, swap?: boolean): string | null;
+    subst(search: Expr, replace: Expr): Expr | null;
+    _format(options: RefinedFormatOptions, nargs: number): string;
+    static global: string[];
 }
-export namespace FreeVar {
-    let global: string[];
+export declare class Native extends Named {
+    /**
+     * @desc A named term with a known rewriting rule.
+     *       'impl' is a function with signature Expr => Expr => ... => Expr
+     *       (see typedef Partial).
+     *       This is how S, K, I, and company are implemented.
+     *
+     *       Note that as of current something like a=>b=>b(a) is not possible,
+     *       use full form instead: a=>b=>b.apply(a).
+     *
+     * @example new Native('K', x => y => x); // constant
+     * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application
+     *
+     * @param {String} name
+     * @param {Partial} impl
+     * @param {{note?: string, arity?: number, canonize?: boolean }} [opt]
+     */
+    constructor(name: string, impl: (e: Expr) => Invocation, opt?: {
+        note?: string;
+        arity?: number;
+        canonize?: boolean;
+    });
 }
-export class Lambda extends Expr {
+export declare class Lambda extends Expr {
     /**
      * @desc Lambda abstraction of arg over impl.
      *     Upon evaluation, all occurrences of 'arg' within 'impl' will be replaced
@@ -565,44 +606,31 @@ export class Lambda extends Expr {
      * @param {FreeVar} arg
      * @param {Expr} impl
      */
-    constructor(arg: FreeVar, impl: Expr);
     arg: FreeVar;
     impl: Expr;
-    arity: number;
-    invoke(arg: any): Expr;
-    _traverse_descend(options: any, change: any): any;
-    any(predicate: any): any;
-    _fold(initial: any, combine: any): any;
-    subst(search: any, replace: any): Lambda;
-    diff(other: any, swap?: boolean): string;
-    _format(options: any, nargs: any): string;
-    _braced(first: any): boolean;
+    constructor(arg: FreeVar, impl: Expr);
+    invoke(arg: Expr): Expr;
+    _traverse_descend(options: TraverseOptions, change: TraverseCallback): TraverseValue<Expr>;
+    any(predicate: (e: Expr) => boolean): boolean;
+    _fold<T>(initial: T, combine: (acc: T, expr: Expr) => TraverseValue<T>): TraverseValue<T>;
+    subst(search: Expr, replace: Expr): Expr | null;
+    diff(other: Expr, swap?: boolean): string | null;
+    _format(options: RefinedFormatOptions, nargs: number): string;
+    _braced(first: boolean): boolean;
 }
-export class Native extends Named {
+export declare class Church extends Expr {
     /**
-     * @desc A named term with a known rewriting rule.
-     *       'impl' is a function with signature Expr => Expr => ... => Expr
-     *       (see typedef Partial).
-     *       This is how S, K, I, and company are implemented.
-     *
-     *       Note that as of current something like a=>b=>b(a) is not possible,
-     *       use full form instead: a=>b=>b.apply(a).
-     *
-     * @example new Native('K', x => y => x); // constant
-     * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application
-     *
-     * @param {String} name
-     * @param {Partial} impl
-     * @param {{note?: string, arity?: number, canonize?: boolean }} [opt]
+     * @desc Church numeral representing non-negative integer n:
+     *      n f x = f(f(...(f x)...)) with f applied n times.
+     * @param {number} n
      */
-    constructor(name: string, impl: Partial, opt?: {
-        note?: string;
-        arity?: number;
-        canonize?: boolean;
-    });
-    invoke: Partial;
+    n: number;
+    constructor(n: number);
+    diff(other: Expr, swap?: boolean): string | null;
+    _unspaced(arg: Expr): boolean;
+    _format(options: RefinedFormatOptions, nargs: number): string;
 }
-export class Alias extends Named {
+export declare class Alias extends Named {
     /**
      * @desc A named alias for an existing expression.
      *
@@ -619,6 +647,9 @@ export class Alias extends Named {
      * @param {Expr} impl
      * @param {{canonize?: boolean, max?: number, maxArgs?: number, note?: string, terminal?: boolean}} [options]
      */
+    terminal?: boolean;
+    impl: Expr;
+    outdated?: boolean;
     constructor(name: string, impl: Expr, options?: {
         canonize?: boolean;
         max?: number;
@@ -626,76 +657,35 @@ export class Alias extends Named {
         note?: string;
         terminal?: boolean;
     });
-    impl: Expr;
-    terminal: any;
-    invoke: (arg: any) => any;
-    _traverse_descend(options: any, change: any): any;
-    any(predicate: any): any;
-    _fold(initial: any, combine: any): any;
-    subst(search: any, replace: any): any;
-    diff(other: any, swap?: boolean): any;
-    _braced(first: any): boolean;
-}
-export class Church extends Expr {
     /**
-     * @desc Church numeral representing non-negative integer n:
-     *      n f x = f(f(...(f x)...)) with f applied n times.
-     * @param {number} n
+     * @property {boolean} [outdated] - whether the alias is outdated
+     *     and should be replaced with its definition when encountered.
+     * @property {boolean} [terminal] - whether the alias should behave like a standalone term
+     *     // TODO better name?
+     * @property {boolean} [proper] - whether the alias is a proper combinator (i.e. contains no free variables or constants)
+     * @property {number} [arity] - the number of arguments the alias waits for before expanding
+     * @property {Expr} [canonical] - equivalent lambda term.
      */
-    constructor(n: number);
-    invoke: (x: any) => (y: any) => any;
-    /** @type {number} */
-    n: number;
-    arity: number;
-    diff(other: any, swap?: boolean): string;
-    _unspaced(arg: any): boolean;
-    _format(options: any, nargs: any): any;
+    _traverse_descend(options: TraverseOptions, change: TraverseCallback): TraverseValue<Expr>;
+    any(predicate: (e: Expr) => boolean): boolean;
+    _fold<T>(initial: T, combine: (acc: T, expr: Expr) => TraverseValue<T>): TraverseValue<T>;
+    subst(search: Expr, replace: Expr): Expr | null;
+    /**
+     * @return {{expr: Expr, steps: number, changed: boolean}}
+     */
+    step(): Step;
+    diff(other: Expr, swap?: boolean): string | null;
+    _braced(first: boolean): boolean;
+    _format(options: RefinedFormatOptions, nargs: number): string;
 }
-/**
- * @desc List of predefined native combinators.
- * This is required for toSKI() to work, otherwise could as well have been in parser.js.
- * @type {{[key: string]: Native}}
- */
-declare const native: {
-    [key: string]: Native;
-};
-/**
- * @template T
- * @typedef {T | TraverseControl<T> | null} TraverseValue
- */
-/**
- * @desc Control primitives for fold() and traverse() methods.
- * @template T
- * @type {{[name: string]: function(T): TraverseControl<T>}}
- */
-declare const control: {
-    [name: string]: (arg0: T) => TraverseControl<T>;
-};
-/**
- * @desc  Sort a list in such a way that dependent terms come after the (named) terms they depend on.
- *        If env is given, only terms listed there are taken into account.
- *        If env is omitted, it will be implied from the list.
- *        If list is omitted, it will default to values of env.
- *        If just one term is given instead of a list, it will be coerced into a list.
- *
- *        No terms outside env + list may ever appear in the result.
- *
- *        The terms in env must be named and their names must match their keys.
- *
- * @param {Expr|Expr[]} list
- * @param {{[s:string]: Named}} env
- * @returns {{list: Expr[], env: {[s:string]: Named}}}
- *
- * @example
- *    const expr = ski.parse(src);
- *    toposort([expr], ski.getTerms()); // returns all terms appearing in Expr in correct order
- */
-declare function toposort(list: Expr | Expr[], env: {
-    [s: string]: Named;
-}): {
-    list: Expr[];
-    env: {
-        [s: string]: Named;
-    };
+export declare const classes: {
+    Expr: typeof Expr;
+    App: typeof App;
+    Named: typeof Named;
+    FreeVar: typeof FreeVar;
+    Native: typeof Native;
+    Lambda: typeof Lambda;
+    Church: typeof Church;
+    Alias: typeof Alias;
 };
 export {};