time-to-botec

index.js (6656B)

---

 import { parse } from "../ast/parse.js";
 import { defaultEnv } from "../dist/env.js";
 import { IRuntimeError, rethrowWithFrameStack, } from "../errors/IError.js";
 import { REExpectedType, RENotAFunction, REOther, } from "../errors/messages.js";
 import { compileAst } from "../expression/compile.js";
 import { getStdLib } from "../library/index.js";
 import { ImmutableMap } from "../utility/immutableMap.js";
 import * as Result from "../utility/result.js";
 import { Ok } from "../utility/result.js";
 import { annotationToDomain } from "../value/domain.js";
 import { vArray, vDict, vDomain, vLambda, vVoid, } from "../value/index.js";
 import * as Context from "./context.js";
 import { UserDefinedLambda } from "./lambda.js";
 function throwFrom(error, context, ast) {
     throw IRuntimeError.fromMessageWithFrameStack(error, context.frameStack.extend(Context.currentFunctionName(context), ast.location));
 }
 export const evaluate = (expression, context) => {
     const ast = expression.ast;
     switch (expression.type) {
         case "Block":
             return evaluateBlock(expression.value, context, ast);
         case "Program":
             return evaluateProgram(expression.value, context, ast);
         case "Array":
             return evaluateArray(expression.value, context, ast);
         case "Dict":
             return evaluateDict(expression.value, context, ast);
         case "Assign":
             return evaluateAssign(expression.value, context, ast);
         case "ResolvedSymbol":
             return evaluateResolvedSymbol(expression.value, context, ast);
         case "Value":
             return evaluateValue(expression.value, context, ast);
         case "Ternary":
             return evaluateTernary(expression.value, context, ast);
         case "Lambda":
             return evaluateLambda(expression.value, context, ast);
         case "Call":
             return evaluateCall(expression.value, context, ast);
         default:
             throw new Error(`Unreachable: ${expression}`);
     }
 };
 const evaluateBlock = (statements, context) => {
     let currentContext = context;
     let currentValue = vVoid();
     for (const statement of statements) {
         [currentValue, currentContext] = context.evaluate(statement, currentContext);
     }
     return [currentValue, context];
 };
 const evaluateProgram = (expressionValue, context) => {
     let currentContext = context;
     let currentValue = vVoid();
     for (const statement of expressionValue.statements) {
         [currentValue, currentContext] = context.evaluate(statement, currentContext);
     }
     return [currentValue, currentContext];
 };
 const evaluateArray = (expressionValue, context) => {
     const values = expressionValue.map((element) => {
         const [value] = context.evaluate(element, context);
         return value;
     });
     const value = vArray(values);
     return [value, context];
 };
 const evaluateDict = (expressionValue, context, ast) => {
     const value = vDict(ImmutableMap(expressionValue.map(([eKey, eValue]) => {
         const [key] = context.evaluate(eKey, context);
         if (key.type !== "String") {
             return throwFrom(new REOther("Dict keys must be strings"), context, ast);
         }
         const keyString = key.value;
         const [value] = context.evaluate(eValue, context);
         return [keyString, value];
     })));
     return [value, context];
 };
 const evaluateAssign = (expressionValue, context) => {
     const [result] = context.evaluate(expressionValue.right, context);
     return [
         vVoid(),
         {
             stack: context.stack.push(expressionValue.left, result),
             environment: context.environment,
             frameStack: context.frameStack,
             evaluate: context.evaluate,
             inFunction: context.inFunction,
         },
     ];
 };
 const evaluateResolvedSymbol = (expressionValue, context) => {
     const value = context.stack.get(expressionValue.offset);
     return [value, context];
 };
 const evaluateValue = (expressionValue, context) => {
     return [expressionValue, context];
 };
 const evaluateTernary = (expressionValue, context, ast) => {
     const [predicateResult] = context.evaluate(expressionValue.condition, context);
     if (predicateResult.type !== "Bool") {
         return throwFrom(new REExpectedType("Boolean", predicateResult.type), context, ast);
     }
     const [value] = context.evaluate(predicateResult.value ? expressionValue.ifTrue : expressionValue.ifFalse, context);
     return [value, context];
 };
 const evaluateLambda = (expressionValue, context, ast) => {
     const parameters = [];
     for (const parameterExpression of expressionValue.parameters) {
         let domain;
         if (parameterExpression.annotation) {
             const [annotationValue] = context.evaluate(parameterExpression.annotation, context);
             try {
                 domain = vDomain(annotationToDomain(annotationValue));
             }
             catch (e) {
                 rethrowWithFrameStack(e, context.frameStack.extend(Context.currentFunctionName(context), parameterExpression.annotation.ast.location));
             }
         }
         parameters.push({
             name: parameterExpression.name,
             domain,
         });
     }
     const value = vLambda(new UserDefinedLambda(expressionValue.name, parameters, context.stack, expressionValue.body, ast.location));
     return [value, context];
 };
 const evaluateCall = (expressionValue, context, ast) => {
     const [lambda] = context.evaluate(expressionValue.fn, context);
     const argValues = expressionValue.args.map((arg) => {
         const [argValue] = context.evaluate(arg, context);
         return argValue;
     });
     switch (lambda.type) {
         case "Lambda": {
             const result = lambda.value.callFrom(argValues, context, ast);
             return [result, context];
         }
         default:
             return throwFrom(new RENotAFunction(lambda.toString()), context, ast);
     }
 };
 function createDefaultContext() {
     return Context.createContext(defaultEnv);
 }
 export async function evaluateExpressionToResult(expression) {
     const context = createDefaultContext();
     try {
         const [value] = context.evaluate(expression, context);
         return Ok(value);
     }
     catch (e) {
         return Result.Err(IRuntimeError.fromException(e));
     }
 }
 export async function evaluateStringToResult(code) {
     const exprR = Result.bind(parse(code, "main"), (ast) => compileAst(ast, getStdLib()));
     if (exprR.ok) {
         return await evaluateExpressionToResult(exprR.value);
     }
     else {
         return Result.Err(exprR.value);
     }
 }
 //# sourceMappingURL=index.js.map