@helios-lang/effect 0.1.14 → 0.2.0

package/dist/Cardano/Uplc/Cek.js

@@ -0,0 +1,716 @@
+import { Either } from "effect";
+import * as Cost from "./Cost.js";
+import { memSize } from "./Value.js";
+/**
+ * This is main evaluation function of the CEK Machine
+ * Stack-based algorithm
+ * @param entryPoint
+ * @param evalContext
+ * @returns
+ */
+function eval$(entryPoint, evalContext) {
+    const tracker = new Cost.Tracker(Cost.makeModel(evalContext.costParams, evalContext.builtins));
+    const logs = [];
+    // initialize the machine state
+    let state = {
+        kind: "computing",
+        term: entryPoint,
+        stack: {
+            values: [],
+            callSites: []
+        },
+        frames: []
+    };
+    /**
+     * Create the full context
+     */
+    const ctx = {
+        ...evalContext,
+        cost: tracker,
+        print: (message, callSite) => {
+            logs.push({ message, callSite: callSite ?? undefined });
+            evalContext.logger?.logPrint(message, callSite);
+        },
+        popLastMessage: () => {
+            return logs.pop()?.message;
+        }
+    };
+    // initialize the execution cost
+    tracker.incrStartupCost();
+    while (!["error", "success"].includes(state.kind)) {
+        if (state.kind == "computing") {
+            switch (state.term._tag) {
+                case "Apply":
+                    state = computeApplyTerm(state, ctx);
+                    break;
+                case "Builtin":
+                    state = computeBuiltinTerm(state, ctx);
+                    break;
+                case "Case":
+                    state = computeCaseTerm(state, ctx);
+                    break;
+                case "Const":
+                    state = computeConstTerm(state, ctx);
+                    break;
+                case "Constr":
+                    state = computeConstrTerm(state, ctx);
+                    break;
+                case "Delay":
+                    state = computeDelayTerm(state, ctx);
+                    break;
+                case "Error":
+                    state = computeErrorTerm(state, ctx);
+                    break;
+                case "Force":
+                    state = computeForceTerm(state, ctx);
+                    break;
+                case "Lambda":
+                    state = computeLambdaTerm(state, ctx);
+                    break;
+                case "Var":
+                    state = computeVarTerm(state, ctx);
+                    break;
+                default:
+                    throw new Error(`Unhandled term kind '${state.term._tag}'`);
+            }
+        }
+        else if (state.kind == "reducing") {
+            const f = state.frames.pop();
+            if (f) {
+                switch (f._tag) {
+                    case "CaseScrutineeFrame":
+                        state = reduceCaseScrutineeFrame(f, state);
+                        break;
+                    case "ConstrArgFrame":
+                        state = reduceConstrArgFrame(f, state);
+                        break;
+                    case "ForceFrame":
+                        state = reduceForceFrame(f, state, ctx);
+                        break;
+                    case "LeftApplyToTermFrame":
+                        state = reduceLeftApplyToTermFrame(f, state);
+                        break;
+                    case "LeftApplyToValueFrame":
+                        state = reduceLeftApplyToValueFrame(f, state, ctx);
+                        break;
+                    case "RightApplyFrame":
+                        state = reduceRightApplyFrame(f, state, ctx);
+                        break;
+                    default:
+                        throw new Error(`Unhandled frame type ${f._tag}`);
+                }
+            }
+            else {
+                state = {
+                    kind: "success",
+                    value: state.value
+                };
+            }
+        }
+    }
+    if (state.kind == "success") {
+        return {
+            value: Either.right(state.value),
+            cost: {
+                mem: tracker.mem,
+                cpu: tracker.cpu
+            },
+            logs: logs,
+            breakdown: tracker.breakdown
+        };
+    }
+    else if (state.kind == "error") {
+        return {
+            value: Either.left({
+                error: state.message,
+                callSites: state.stack.callSites
+            }),
+            cost: {
+                mem: tracker.mem,
+                cpu: tracker.cpu
+            },
+            logs: logs,
+            breakdown: tracker.breakdown
+        };
+    }
+    else {
+        throw new Error(`Internal error: unexpected final state ${state.kind}`);
+    }
+}
+export { eval$ as eval };
+function computeApplyTerm({ term, stack, frames }, machineContext) {
+    machineContext.cost.incrApplyCost();
+    return {
+        kind: "computing",
+        term: term.fn,
+        stack,
+        frames: frames.concat([
+            {
+                _tag: "LeftApplyToTermFrame",
+                arg: term.arg,
+                stack,
+                callSite: {
+                    sourceSpan: term.sourceSpan
+                }
+            }
+        ])
+    };
+}
+function computeBuiltinTerm({ term, frames }, ctx) {
+    ctx.cost.incrBuiltinCost();
+    return {
+        kind: "reducing",
+        value: {
+            _tag: "Builtin",
+            id: term.id,
+            name: ctx.builtins[term.id]?.name ?? term.name,
+            args: [],
+            forceCount: 0 // TODO: count down instead of up
+        },
+        frames: frames
+    };
+}
+function computeCaseTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrCaseCost();
+    return {
+        kind: "computing",
+        term: term.arg,
+        stack,
+        frames: frames.concat([
+            {
+                _tag: "CaseScrutineeFrame",
+                cases: term.cases,
+                stack
+            }
+        ])
+    };
+}
+function computeConstTerm({ term, frames }, ctx) {
+    ctx.cost.incrConstCost();
+    return {
+        kind: "reducing",
+        value: term,
+        frames: frames
+    };
+}
+function computeConstrTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrConstrCost();
+    if (term.args.length == 0) {
+        return {
+            kind: "reducing",
+            value: {
+                _tag: "Constr",
+                tag: term.tag,
+                args: []
+            },
+            frames
+        };
+    }
+    else {
+        return {
+            kind: "computing",
+            term: term.args[0],
+            stack,
+            frames: frames.concat([
+                {
+                    _tag: "ConstrArgFrame",
+                    tag: term.tag,
+                    evaluatedArgs: [],
+                    pendingArgs: term.args.slice(1),
+                    stack
+                }
+            ])
+        };
+    }
+}
+function computeDelayTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrDelayCost();
+    return {
+        kind: "reducing",
+        value: {
+            _tag: "Delayed",
+            term: term.arg,
+            stack,
+            name: term.name
+        },
+        frames
+    };
+}
+function computeErrorTerm({ stack }, ctx) {
+    return {
+        kind: "error",
+        message: ctx.popLastMessage() ?? "",
+        stack: stack
+    };
+}
+function computeForceTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrForceCost();
+    return {
+        kind: "computing",
+        term: term.arg,
+        stack,
+        frames: frames.concat([
+            {
+                _tag: "ForceFrame",
+                stack,
+                callSite: {
+                    sourceSpan: term.sourceSpan
+                }
+            }
+        ])
+    };
+}
+function computeLambdaTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrLambdaCost();
+    return {
+        kind: "reducing",
+        value: {
+            _tag: "Lambda",
+            body: term.body,
+            stack,
+            argName: term.argName ?? undefined,
+            name: term.name ?? undefined
+        },
+        frames
+    };
+}
+function computeVarTerm({ term, stack, frames }, ctx) {
+    ctx.cost.incrVarCost();
+    const i = stack.values.length - term.index;
+    const v = stack.values[i];
+    if (v === undefined) {
+        return {
+            kind: "error",
+            message: `var ${term.index} out of stack range (stack has ${stack.values.length} values)${term.name !== undefined ? `, '${term.name}'` : ""}`,
+            stack
+        };
+    }
+    else {
+        return {
+            kind: "reducing",
+            value: v,
+            frames
+        };
+    }
+}
+function reduceCaseScrutineeFrame(frame, { frames, value }) {
+    if (value._tag == "Constr") {
+        const tag = value.tag;
+        const c = frame.cases[tag];
+        if (c === undefined) {
+            return {
+                kind: "error",
+                message: "constr id out of range",
+                stack: frame.stack
+            };
+        }
+        const callFrames = value.args.map((a) => ({
+            _tag: "LeftApplyToValueFrame",
+            rhs: a,
+            stack: frame.stack,
+            callSite: undefined
+        }));
+        callFrames.reverse();
+        return {
+            kind: "computing",
+            term: c,
+            stack: frame.stack,
+            // TODO: callSite
+            frames: frames.concat(callFrames)
+        };
+    }
+    else {
+        return {
+            kind: "error",
+            message: "expected constr value case",
+            stack: frame.stack
+        };
+    }
+}
+function reduceConstrArgFrame(frame, { frames, value }) {
+    const evaluatedArgs = frame.evaluatedArgs.concat([value]);
+    if (frame.pendingArgs.length == 0) {
+        return {
+            kind: "reducing",
+            value: {
+                _tag: "Constr",
+                tag: frame.tag,
+                args: evaluatedArgs
+            },
+            frames
+        };
+    }
+    else {
+        return {
+            kind: "computing",
+            term: frame.pendingArgs[0],
+            stack: frame.stack,
+            frames: frames.concat([
+                {
+                    _tag: "ConstrArgFrame",
+                    tag: frame.tag,
+                    evaluatedArgs,
+                    pendingArgs: frame.pendingArgs.slice(1),
+                    stack: frame.stack
+                }
+            ])
+        };
+    }
+}
+/**
+ * Only needed for debugging
+ * Needed to add stack trace frames for variables like `self`
+ * TODO: might introduce unnecessary overhead and thus require a flag to switch off
+ * @param stack
+ * @returns
+ */
+function getLastSelfValue(stack) {
+    const last = stack.values[stack.values.length - 1];
+    if (last?.name == "self") {
+        return last;
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * @param stackWithValues
+ * @param stackWithCallSites
+ * @returns
+ */
+function mixStacks(stackWithValues, stackWithCallSites) {
+    return {
+        values: stackWithValues.values,
+        callSites: stackWithCallSites.callSites
+    };
+}
+/**
+ * @param callSite
+ * @returns
+ */
+export function isEmptyCallSiteInfo(callSite) {
+    return (callSite === undefined ||
+        (callSite.sourceSpan === undefined &&
+            callSite.functionName === undefined &&
+            callSite.arguments === undefined));
+}
+/**
+ * @param callSite
+ * @returns
+ */
+export function isNonEmptyCallSiteInfo(callSite) {
+    return !isEmptyCallSiteInfo(callSite);
+}
+/**
+ * @param stack
+ * @param callSite
+ * @returns
+ */
+function pushStackCallSite(stack, callSite) {
+    if (isNonEmptyCallSiteInfo(callSite)) {
+        return {
+            values: stack.values,
+            callSites: stack.callSites.concat([callSite])
+        };
+    }
+    else {
+        return stack;
+    }
+}
+/**
+ * @param stack
+ * @param callSites
+ * @returns
+ */
+export function pushStackCallSites(stack, ...callSites) {
+    return {
+        values: stack.values,
+        callSites: stack.callSites.concat(callSites.filter(isNonEmptyCallSiteInfo))
+    };
+}
+/**
+ * @param stack
+ * @param value
+ * @returns
+ */
+export function pushStackValue(stack, value) {
+    return {
+        values: stack.values.concat([value]),
+        callSites: stack.callSites
+    };
+}
+/**
+ * @param stack
+ * @param value
+ * @param callSite
+ * @returns
+ */
+export function pushStackValueAndCallSite(stack, value, callSite) {
+    return {
+        values: stack.values.concat([value]),
+        callSites: stack.callSites.concat(isNonEmptyCallSiteInfo(callSite) ? [callSite] : [])
+    };
+}
+/**
+ * @param stack
+ * @param value
+ * @param callSites
+ * @returns
+ */
+export function pushStackValueAndCallSites(stack, value, ...callSites) {
+    return {
+        values: stack.values.concat([value]),
+        callSites: stack.callSites.concat(callSites)
+    };
+}
+function reduceForceFrame(frame, { frames, value }, ctx) {
+    if (value._tag == "Delayed") {
+        /**
+         * TODO: cleaner way of getting `self` and other variables that are in the stacks of callbacks
+         */
+        const lastSelfValue = getLastSelfValue(value.stack);
+        return {
+            kind: "computing",
+            term: value.term,
+            stack: mixStacks(value.stack, pushStackCallSite(frame.stack, frame.callSite?.sourceSpan
+                ? {
+                    sourceSpan: frame.callSite?.sourceSpan,
+                    functionName: value.name,
+                    arguments: lastSelfValue ? [lastSelfValue] : undefined
+                }
+                : undefined)),
+            frames
+        };
+    }
+    else if (value._tag == "Builtin") {
+        const b = ctx.builtins[value.id];
+        if (b === undefined) {
+            return {
+                kind: "error",
+                message: `builtin ${value.id} not found`,
+                stack: frame.stack
+            };
+        }
+        else if (value.forceCount >= b.forceCount) {
+            return {
+                kind: "error",
+                message: `too many forces for builtin ${b.name}, ${value.forceCount + 1} > ${b.forceCount}`,
+                stack: frame.stack
+            };
+        }
+        else {
+            return {
+                kind: "reducing",
+                value: {
+                    ...value,
+                    forceCount: value.forceCount + 1
+                },
+                frames
+            };
+        }
+    }
+    else {
+        return {
+            kind: "error",
+            message: "expected delayed or builtin value for force",
+            stack: frame.stack
+        };
+    }
+}
+/**
+ * @param {CekFrame[]} frames
+ * @param {CekValue} value - fn value
+ * @param {CekContext} _ctx
+ * @returns {CekState}
+ */
+function reduceLeftApplyToTermFrame(frame, { frames, value }) {
+    if (value._tag == "Lambda") {
+        const mixedEnv = mixStacks(value.stack, frame.stack);
+        return {
+            kind: "computing",
+            term: frame.arg,
+            stack: frame.stack,
+            frames: frames.concat([
+                {
+                    _tag: "RightApplyFrame",
+                    fn: {
+                        ...value,
+                        stack: mixedEnv
+                    },
+                    stack: mixedEnv,
+                    info: {
+                        callSite: frame.callSite,
+                        name: value.name,
+                        argName: value.argName
+                    }
+                }
+            ])
+        };
+    }
+    else {
+        return {
+            kind: "computing",
+            term: frame.arg,
+            stack: frame.stack,
+            frames: frames.concat([
+                {
+                    _tag: "RightApplyFrame",
+                    fn: value,
+                    stack: frame.stack,
+                    info: {
+                        callSite: frame.callSite
+                    }
+                }
+            ])
+        };
+    }
+}
+/**
+ * If the `leftValue` is a lambda function, perform the following transition:
+ *
+ * $$
+ * [\langle\text{lam}~x~M~\rho\rangle~V]
+ * $$
+ * @param frames
+ * @param leftValue
+ * @param rightValue
+ * @param frameStack
+ * @param ctx
+ * @param machineContext
+ * @param info
+ * @returns
+ */
+function reduceApplyToFrame(frames, leftValue, rightValue, frameStack, ctx, info = {}) {
+    if (info.argName !== undefined) {
+        rightValue = {
+            ...rightValue,
+            name: info.argName
+        };
+    }
+    if (leftValue._tag == "Lambda") {
+        /**
+         * TODO: cleaner way of getting `self` and other variables that are in the stacks of callbacks
+         */
+        const lastSelfValue = getLastSelfValue(frameStack);
+        const callSite = {
+            sourceSpan: info.callSite?.sourceSpan,
+            functionName: info.name,
+            arguments: lastSelfValue ? [lastSelfValue, rightValue] : [rightValue]
+        };
+        return {
+            kind: "computing",
+            term: leftValue.body,
+            stack: pushStackValueAndCallSite(leftValue.stack, rightValue, callSite),
+            frames
+        };
+    }
+    else if (leftValue._tag == "Builtin") {
+        const b = ctx.builtins[leftValue.id];
+        if (b === undefined) {
+            return {
+                kind: "error",
+                message: `builtin ${leftValue.id} not found`,
+                stack: frameStack
+            };
+        }
+        else if (b.forceCount > leftValue.forceCount) {
+            return {
+                kind: "error",
+                message: `insufficient forces applied to ${b.name}, ${leftValue.forceCount} < ${b.forceCount}`,
+                stack: frameStack
+            };
+        }
+        else {
+            const args = leftValue.args.concat([rightValue]);
+            if (args.length == b.nArgs) {
+                ctx.cost.incrArgSizesCost(b.name, args.map((a) => {
+                    if ("value" in a) {
+                        return memSize(a.value);
+                    }
+                    else {
+                        return 1;
+                    }
+                }));
+                const callSites = args.map((a, i) => {
+                    if (i == args.length - 1) {
+                        return {
+                            site: info.callSite,
+                            functionName: b.name,
+                            argument: a
+                        };
+                    }
+                    else {
+                        return {
+                            argument: a
+                        };
+                    }
+                });
+                const callResult = b.call(args, {
+                    ...ctx,
+                    print: (message) => {
+                        ctx.print(message, info.callSite);
+                    }
+                });
+                if (callResult._tag == "Left") {
+                    return {
+                        kind: "error",
+                        message: callResult.left.message ?? callResult.left._tag,
+                        stack: pushStackCallSites(frameStack, ...callSites)
+                    };
+                }
+                else {
+                    return {
+                        kind: "reducing",
+                        value: callResult.right,
+                        frames
+                    };
+                }
+            }
+            else {
+                return {
+                    kind: "reducing",
+                    value: {
+                        _tag: "Builtin",
+                        id: leftValue.id,
+                        name: leftValue.name,
+                        forceCount: b.forceCount,
+                        args: args
+                    },
+                    frames
+                };
+            }
+        }
+    }
+    else {
+        return {
+            kind: "error",
+            message: `can only call lambda or builtin terms`,
+            stack: frameStack
+        };
+    }
+}
+function reduceLeftApplyToValueFrame(frame, { frames, value }, ctx) {
+    return reduceApplyToFrame(frames, value, frame.rhs, frame.stack, ctx, {
+        callSite: frame.callSite
+    });
+}
+/**
+ * @param {CekFrame[]} frames
+ * @param {CekValue} value
+ * @param {CekContext} ctx
+ * @returns {CekState}
+ */
+function reduceRightApplyFrame(frame, { frames, value }, ctx) {
+    return reduceApplyToFrame(frames, frame.fn, value, frame.stack, ctx, frame.info);
+}
+/**
+ * Instantiate a `Machine` with {@link makeCekMachine}.
+ */
+//export interface Machine extends Context {
+//  readonly builtins: Builtin[]
+//  readonly logger: Logger | undefined
+//  readonly state: State
+//  readonly trace: { message: string; site?: Site }[]
+//  eval(): Result
+//}
+//# sourceMappingURL=Cek.js.map