time-to-botec

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

index.js (3091B)

      1 import { vVoid } from "../value/index.js";
      2 export const eArray = (anArray) => ({
      3     type: "Array",
      4     value: anArray,
      5 });
      6 export const eValue = (value) => ({
      7     type: "Value",
      8     value,
      9 });
     10 export const eCall = (fn, args) => ({
     11     type: "Call",
     12     value: {
     13         fn,
     14         args,
     15     },
     16 });
     17 export const eLambda = (name, parameters, body) => ({
     18     type: "Lambda",
     19     value: {
     20         name,
     21         parameters,
     22         body,
     23     },
     24 });
     25 export const eDict = (aMap) => ({
     26     type: "Dict",
     27     value: aMap,
     28 });
     29 export const eResolvedSymbol = (name, offset) => ({
     30     type: "ResolvedSymbol",
     31     value: { name, offset },
     32 });
     33 export const eBlock = (exprs) => ({
     34     type: "Block",
     35     value: exprs,
     36 });
     37 export const eProgram = (statements, exports) => ({
     38     type: "Program",
     39     value: {
     40         statements,
     41         exports,
     42     },
     43 });
     44 export const eLetStatement = (left, right) => ({
     45     type: "Assign",
     46     value: {
     47         left,
     48         right,
     49     },
     50 });
     51 export const eTernary = (condition, ifTrue, ifFalse) => ({
     52     type: "Ternary",
     53     value: {
     54         condition,
     55         ifTrue,
     56         ifFalse,
     57     },
     58 });
     59 export const eVoid = () => ({
     60     type: "Value",
     61     value: vVoid(),
     62 });
     63 export function expressionToString(expression) {
     64     switch (expression.type) {
     65         case "Block":
     66             return `{${expression.value.map(expressionToString).join("; ")}}`;
     67         case "Program": {
     68             const exports = new Set(expression.value.exports);
     69             return expression.value.statements
     70                 .map((statement) => {
     71                 const statementString = expressionToString(statement);
     72                 return statement.type === "Assign" &&
     73                     exports.has(statement.value.left)
     74                     ? `export ${statementString}`
     75                     : statementString;
     76             })
     77                 .join("; ");
     78         }
     79         case "Array":
     80             return `[${expression.value.map(expressionToString).join(", ")}]`;
     81         case "Dict":
     82             return `{${expression.value
     83                 .map(([key, value]) => `${expressionToString(key)}: ${expressionToString(value)}`)
     84                 .join(", ")}}`;
     85         case "ResolvedSymbol":
     86             return expression.value.name;
     87         case "Ternary":
     88             return `${expressionToString(expression.value.condition)} ? (${expressionToString(expression.value.ifTrue)}) : (${expressionToString(expression.value.ifFalse)})`;
     89         case "Assign":
     90             return `${expression.value.left} = ${expressionToString(expression.value.right)}`;
     91         case "Call":
     92             return `(${expressionToString(expression.value.fn)})(${expression.value.args.map(expressionToString).join(", ")})`;
     93         case "Lambda":
     94             return `{|${expression.value.parameters
     95                 .map((parameter) => parameter.name)
     96                 .join(", ")}| ${expressionToString(expression.value.body)}}`;
     97         case "Value":
     98             return expression.value.toString();
     99         default:
    100             return `Unknown expression ${expression}`;
    101     }
    102 }
    103 //# sourceMappingURL=index.js.map