time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

index.d.ts (2249B)

      1 import { ASTNode } from "../ast/parse.js";
      2 import { Value } from "../value/index.js";
      3 export type LambdaExpressionParameter = {
      4     name: string;
      5     annotation?: Expression;
      6 };
      7 export type ExpressionContent = {
      8     type: "Block";
      9     value: Expression[];
     10 } | {
     11     type: "Program";
     12     value: {
     13         statements: Expression[];
     14         exports: string[];
     15     };
     16 } | {
     17     type: "Array";
     18     value: Expression[];
     19 } | {
     20     type: "Dict";
     21     value: [Expression, Expression][];
     22 } | {
     23     type: "ResolvedSymbol";
     24     value: {
     25         name: string;
     26         offset: number;
     27     };
     28 } | {
     29     type: "Ternary";
     30     value: {
     31         condition: Expression;
     32         ifTrue: Expression;
     33         ifFalse: Expression;
     34     };
     35 } | {
     36     type: "Assign";
     37     value: {
     38         left: string;
     39         right: Expression;
     40     };
     41 } | {
     42     type: "Call";
     43     value: {
     44         fn: Expression;
     45         args: Expression[];
     46     };
     47 } | {
     48     type: "Lambda";
     49     value: {
     50         name?: string;
     51         parameters: LambdaExpressionParameter[];
     52         body: Expression;
     53     };
     54 } | {
     55     type: "Value";
     56     value: Value;
     57 };
     58 export type Expression = ExpressionContent & {
     59     ast: ASTNode;
     60 };
     61 export declare const eArray: (anArray: Expression[]) => ExpressionContent;
     62 export declare const eValue: (value: Value) => ExpressionContent;
     63 export declare const eCall: (fn: Expression, args: Expression[]) => ExpressionContent;
     64 export declare const eLambda: (name: string | undefined, parameters: LambdaExpressionParameter[], body: Expression) => ExpressionContent;
     65 export declare const eDict: (aMap: [Expression, Expression][]) => ExpressionContent;
     66 export declare const eResolvedSymbol: (name: string, offset: number) => ExpressionContent;
     67 export declare const eBlock: (exprs: Expression[]) => ExpressionContent;
     68 export declare const eProgram: (statements: Expression[], exports: string[]) => ExpressionContent;
     69 export declare const eLetStatement: (left: string, right: Expression) => ExpressionContent;
     70 export declare const eTernary: (condition: Expression, ifTrue: Expression, ifFalse: Expression) => ExpressionContent;
     71 export declare const eVoid: () => ExpressionContent;
     72 export declare function expressionToString(expression: Expression): string;
     73 //# sourceMappingURL=index.d.ts.map