yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/evaluators/ExpressionEvaluator.js

@@ -0,0 +1,298 @@
+import { Application, NamedArgument, Generator as YuGenerator, SymbolPrimitive, Return, Sequence, Super, UnguardedBody, VariablePattern, } from "yukigo-ast";
+import { BindCommand, FailCommand, RaiseCommand, StepCommand, } from "../kernel/commands.js";
+import { InterpreterError } from "../../errors.js";
+import { YuArray, RuntimeClass, RuntimeFunction, } from "../../primitives/index.js";
+import { boolean, error, isTrue, raise } from "../../utils.js";
+import { EnvBuilderVisitor } from "../EnvBuilder.js";
+import { getClassFields, getClassInitializers, getLogicEngine, } from "./utils.js";
+export function ExpressionEvaluator(Base) {
+    return class extends Base {
+        visitTupleExpr(node) {
+            const results = [];
+            const evaluateNext = (index) => {
+                if (index >= node.elements.length)
+                    return new StepCommand(new YuArray(results));
+                return new BindCommand(this.evaluate(node.elements[index]), (val) => {
+                    results.push(val);
+                    return evaluateNext(index + 1);
+                });
+            };
+            return evaluateNext(0);
+        }
+        visitFieldExpression(node) {
+            return new BindCommand(this.evaluate(node.name), (obj) => {
+                return new StepCommand(this.context.objRuntime.getField(obj, node.name.value));
+            });
+        }
+        visitDataExpr(node) {
+            const fieldValues = new Map();
+            const evaluateFields = (index) => {
+                if (index >= node.contents.length) {
+                    const identifier = node.name.value;
+                    const classDef = new RuntimeClass(identifier, fieldValues, new Map(), []);
+                    return new StepCommand(classDef.instantiate(identifier));
+                }
+                const field = node.contents[index];
+                return new BindCommand(this.evaluate(field.expression), (value) => {
+                    fieldValues.set(field.name.value, value);
+                    return evaluateFields(index + 1);
+                });
+            };
+            return evaluateFields(0);
+        }
+        visitConsExpr(node) {
+            return this.context.lazyRuntime.evaluateCons(node, this);
+        }
+        visitLetInExpr(node) {
+            const oldEnv = this.context.env;
+            this.context.pushEnv();
+            const envBuilder = new EnvBuilderVisitor(this.context);
+            node.declarations.accept(envBuilder);
+            return new BindCommand(this.evaluate(node.expression), (result) => {
+                this.context.env = oldEnv;
+                return new StepCommand(result);
+            });
+        }
+        visitCall(node) {
+            return new BindCommand(this.evaluate(node.callee), (callee) => {
+                const args = [];
+                const evaluateArgs = (index) => {
+                    if (index < node.args.length)
+                        return new BindCommand(this.evaluate(node.args[index]), (val) => {
+                            args.push(val);
+                            return evaluateArgs(index + 1);
+                        });
+                    if (!(callee instanceof RuntimeFunction))
+                        return new FailCommand(new InterpreterError("Call", "Target is not a function"));
+                    return this.context.funcRuntime.apply(callee, args);
+                };
+                return evaluateArgs(0);
+            });
+        }
+        visitOtherwise(node) {
+            return boolean(true);
+        }
+        visitCompositionExpression(node) {
+            return new BindCommand(this.evaluate(node.left), (f) => {
+                return new BindCommand(this.evaluate(node.right), (g) => {
+                    if (!(f instanceof RuntimeFunction) ||
+                        !(g instanceof RuntimeFunction)) {
+                        return new FailCommand(new InterpreterError("Composition", "Both operands of (.) must be functions"));
+                    }
+                    const F_REF = "__internal_f";
+                    const G_REF = "__internal_g";
+                    const PARAM_NAME = "__x";
+                    const compositionBody = new Application(new SymbolPrimitive(F_REF), new Application(new SymbolPrimitive(G_REF), new SymbolPrimitive(PARAM_NAME)));
+                    const patterns = [
+                        new VariablePattern(new SymbolPrimitive(PARAM_NAME)),
+                    ];
+                    const equation = {
+                        patterns,
+                        body: new UnguardedBody(new Sequence([new Return(compositionBody)])),
+                    };
+                    const privateScope = new Map();
+                    privateScope.set(F_REF, f);
+                    privateScope.set(G_REF, g);
+                    const capturedEnv = {
+                        head: privateScope,
+                        tail: this.context.env,
+                    };
+                    const func = new RuntimeFunction(1, [equation], `<(${f.identifier} . ${g.identifier})>`, [], capturedEnv);
+                    return new StepCommand(func);
+                });
+            });
+        }
+        visitLambda(node) {
+            const patterns = node.parameters;
+            const equation = {
+                patterns,
+                body: new UnguardedBody(new Sequence([new Return(node.body)])),
+            };
+            const func = new RuntimeFunction(patterns.length, [equation], "<lambda>", [], this.context.env);
+            return new StepCommand(func);
+        }
+        visitGuardedExpression(expr) {
+            const tryNextGuard = (guardIndex) => {
+                if (guardIndex >= expr.guards.length) {
+                    return new RaiseCommand(new InterpreterError("PatternMatch", "Non-exhaustive guards in equation: the pattern matched but no guard succeeded."));
+                }
+                const guard = expr.guards[guardIndex];
+                return new BindCommand(this.evaluate(guard.condition), (cond) => {
+                    if (!isTrue(cond))
+                        return tryNextGuard(guardIndex + 1);
+                    return this.evaluate(guard.body);
+                });
+            };
+            return tryNextGuard(0);
+        }
+        visitApplication(node) {
+            const { funcRuntime } = this.context;
+            return new BindCommand(this.evaluate(node.functionExpr), (func) => {
+                if (!(func instanceof RuntimeFunction)) {
+                    return new FailCommand(new InterpreterError("Application", "Cannot apply non-function"));
+                }
+                const applyFuncToNode = (func) => new BindCommand(this.evaluate(node.parameter), (arg) => {
+                    return funcRuntime.applyArguments(func, [() => arg]);
+                });
+                if (func.arity === 0) {
+                    return new BindCommand(funcRuntime.applyArguments(func), (resultOfFunc) => {
+                        if (!(resultOfFunc instanceof RuntimeFunction))
+                            return new FailCommand(new InterpreterError("Application", "Cannot apply non-function result of arity-0 function"));
+                        return applyFuncToNode(resultOfFunc);
+                    });
+                }
+                return applyFuncToNode(func);
+            });
+        }
+        visitExist(node) {
+            return getLogicEngine(this, this.context).solveGoalLike(node);
+        }
+        visitNot(node) {
+            return getLogicEngine(this, this.context).solveNot(node);
+        }
+        visitFindall(node) {
+            return getLogicEngine(this, this.context).solveFindall(node);
+        }
+        visitForall(node) {
+            return getLogicEngine(this, this.context).solveForall(node);
+        }
+        visitGoal(node) {
+            return getLogicEngine(this, this.context).solveGoalLike(node);
+        }
+        visitSend(node) {
+            if (node.receiver instanceof Super) {
+                const methodName = node.selector.value;
+                const args = [];
+                const evaluateNextArg = (index) => {
+                    if (index >= node.args.length) {
+                        try {
+                            return this.context.objRuntime.dispatchSuper(methodName, args);
+                        }
+                        catch (error) {
+                            if (error instanceof InterpreterError) {
+                                const mappedErrors = this.context.dispatchHook("onInterpreterError", error, this.context);
+                                const userException = mappedErrors.find((res) => res !== undefined && res !== null);
+                                return new RaiseCommand(userException || error);
+                            }
+                            return new RaiseCommand(new InterpreterError("RuntimeError", String(error)));
+                        }
+                    }
+                    return new BindCommand(this.evaluate(node.args[index]), (val) => {
+                        args.push(val);
+                        return evaluateNextArg(index + 1);
+                    });
+                };
+                return evaluateNextArg(0);
+            }
+            return new BindCommand(this.evaluate(node.receiver), (receiver) => {
+                const methodName = node.selector.value;
+                const args = [];
+                const evaluateNextArg = (index) => {
+                    if (index >= node.args.length) {
+                        try {
+                            return this.context.objRuntime.dispatch(receiver, methodName, args);
+                        }
+                        catch (error) {
+                            if (error instanceof InterpreterError) {
+                                const mappedErrors = this.context.dispatchHook("onInterpreterError", error, this.context);
+                                const userException = mappedErrors.find((res) => res !== undefined && res !== null);
+                                return new RaiseCommand(userException || error);
+                            }
+                            return new RaiseCommand(new InterpreterError("RuntimeError", String(error)));
+                        }
+                    }
+                    return new BindCommand(this.evaluate(node.args[index]), (val) => {
+                        args.push(val);
+                        return evaluateNextArg(index + 1);
+                    });
+                };
+                return evaluateNextArg(0);
+            });
+        }
+        visitNew(node) {
+            const className = node.identifier.value;
+            const classDef = this.context.lookup(className);
+            if (!(classDef instanceof RuntimeClass))
+                return new FailCommand(new InterpreterError("New", `${className} is not a class.`));
+            const instance = classDef.instantiate(node.identifier.value);
+            instance.fields = getClassFields(classDef, this.context);
+            const evaluateArgs = (index) => {
+                if (index >= node.args.length) {
+                    return new StepCommand(instance);
+                }
+                const arg = node.args[index];
+                if (arg instanceof NamedArgument ||
+                    arg.constructor.name === "NamedArgument") {
+                    const fieldName = arg.identifier.value;
+                    return new BindCommand(this.evaluate(arg.expression), (val) => {
+                        instance.setField(fieldName, val);
+                        return evaluateArgs(index + 1);
+                    });
+                }
+                return evaluateArgs(index + 1);
+            };
+            const initializers = getClassInitializers(classDef, this.context);
+            const initializerKeys = Array.from(initializers.keys());
+            const evaluateInitializers = (keyIndex) => {
+                if (keyIndex >= initializerKeys.length) {
+                    return evaluateArgs(0);
+                }
+                const key = initializerKeys[keyIndex];
+                const expr = initializers.get(key);
+                return new BindCommand(this.evaluate(expr), (val) => {
+                    instance.setField(key, val);
+                    return evaluateInitializers(keyIndex + 1);
+                });
+            };
+            return evaluateInitializers(0);
+        }
+        visitListComprehension(node) {
+            const results = [];
+            const process = (index) => {
+                if (index >= node.generators.length) {
+                    return new BindCommand(this.evaluate(node.projection), (proj) => {
+                        results.push(proj);
+                        return new StepCommand(new YuArray(results));
+                    });
+                }
+                const current = node.generators[index];
+                if (current instanceof YuGenerator) {
+                    return new BindCommand(this.evaluate(current.expression), (exprResult) => {
+                        return new BindCommand(this.context.lazyRuntime.realizeList(exprResult), (sourceListVal) => {
+                            const sourceList = sourceListVal.asSequence;
+                            if (!(sourceList instanceof YuArray))
+                                return raise(error("visitListComprehension", `Error expected YuArray and got ${sourceListVal.getType()}`));
+                            const iterateSource = (sourceIndex) => {
+                                if (sourceIndex >= sourceList.items.length)
+                                    return new StepCommand(new YuArray(results));
+                                const item = sourceList.at(sourceIndex);
+                                const varName = current.variable.value;
+                                this.context.define(varName, item);
+                                return process(index + 1);
+                            };
+                            return iterateSource(0);
+                        });
+                    });
+                }
+                else {
+                    return new BindCommand(this.evaluate(current), (condition) => {
+                        return isTrue(condition)
+                            ? process(index + 1)
+                            : new StepCommand(new YuArray(results));
+                    });
+                }
+            };
+            this.context.pushEnv();
+            return process(0);
+        }
+        visitGenerator(node) {
+            return this.evaluate(node.expression);
+        }
+        visitRangeExpression(node) {
+            return this.context.lazyRuntime.evaluateRange(node, this);
+        }
+        visitTypeCast(node) {
+            return node.expression.accept(this);
+        }
+    };
+}

package/dist/interpreter/components/evaluators/OperationEvaluator.d.ts

@@ -0,0 +1,25 @@
+import { ArithmeticBinaryOperation, ArithmeticUnaryOperation, AssignOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, ComparisonOperation, ListBinaryOperation, ListUnaryOperation, LogicalBinaryOperation, LogicalUnaryOperation, StringOperation, UnifyOperation } from "yukigo-ast";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { Constructor, EvaluatorBase } from "./BaseEvaluator.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+export declare function OperationEvaluator<TBase extends Constructor<EvaluatorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): ExecutionCommand;
+        visitListUnaryOperation(node: ListUnaryOperation): ExecutionCommand;
+        visitListBinaryOperation(node: ListBinaryOperation): ExecutionCommand;
+        visitComparisonOperation(node: ComparisonOperation): ExecutionCommand;
+        visitLogicalBinaryOperation(node: LogicalBinaryOperation): ExecutionCommand;
+        visitLogicalUnaryOperation(node: LogicalUnaryOperation): ExecutionCommand;
+        visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): ExecutionCommand;
+        visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): ExecutionCommand;
+        visitStringOperation(node: StringOperation): ExecutionCommand;
+        visitUnifyOperation(node: UnifyOperation): ExecutionCommand;
+        visitAssignOperation(node: AssignOperation): ExecutionCommand;
+        visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+    };
+} & TBase;

package/dist/interpreter/components/evaluators/OperationEvaluator.js

@@ -0,0 +1,226 @@
+import { SymbolPrimitive, } from "yukigo-ast";
+import { BindCommand, EvalCommand, FailCommand, RaiseCommand, StepCommand, } from "../kernel/commands.js";
+import { ArithmeticBinaryTable, ArithmeticUnaryTable, BitwiseBinaryTable, BitwiseUnaryTable, ComparisonOperationTable, ListBinaryTable, ListUnaryTable, LogicalBinaryTable, LogicalUnaryTable, StringOperationTable, } from "../Operations.js";
+import { InterpreterError } from "../../errors.js";
+import { LazyList, RuntimeObject, YuBoolean, YuNumber, } from "../../primitives/index.js";
+import { YukigoKernel } from "../kernel/index.js";
+import { EqualityComparer } from "../EqualityComparer.js";
+import { boolean, error, isTrue, raise } from "../../utils.js";
+import { getLogicEngine } from "./utils.js";
+const processBinary = (evaluator, node, table, typeGuard, contextName) => {
+    return new BindCommand(evaluator.evaluate(node.left), (rawLeft) => {
+        return new BindCommand(evaluator.context.forceValue(rawLeft), (left) => {
+            return new BindCommand(evaluator.evaluate(node.right), (rawRight) => {
+                return new BindCommand(evaluator.context.forceValue(rawRight), (right) => {
+                    if (!typeGuard(left, right)) {
+                        return new FailCommand(new InterpreterError(contextName, `Type mismatch: ${left.getType()}, ${right.getType()}`));
+                    }
+                    const fn = table[node.operator];
+                    if (!fn) {
+                        return new FailCommand(new InterpreterError(contextName, `Unknown op: ${node.operator}`));
+                    }
+                    try {
+                        return fn(left, right);
+                    }
+                    catch (e) {
+                        return new FailCommand(e);
+                    }
+                });
+            });
+        });
+    });
+};
+const processUnary = (evaluator, node, table, typeGuard, contextName) => {
+    return new BindCommand(evaluator.evaluate(node.operand), (rawOperand) => {
+        return new BindCommand(evaluator.context.forceValue(rawOperand), (operand) => {
+            if (!typeGuard(operand))
+                return new FailCommand(new InterpreterError(contextName, `Type mismatch: ${operand.getType()}`));
+            const fn = table[node.operator];
+            if (!fn)
+                return new FailCommand(new InterpreterError(contextName, `Unknown op: ${node.operator}`));
+            try {
+                return fn(operand);
+            }
+            catch (e) {
+                return new FailCommand(e);
+            }
+        });
+    });
+};
+export function OperationEvaluator(Base) {
+    return class extends Base {
+        visitArithmeticUnaryOperation(node) {
+            return processUnary(this, node, ArithmeticUnaryTable, (a) => !!a.asNumeric, "ArithmeticUnaryOperation");
+        }
+        visitListUnaryOperation(node) {
+            return new BindCommand(this.evaluate(node.operand), (rawOperand) => {
+                return new BindCommand(this.context.forceValue(rawOperand), (operand) => {
+                    if (!operand.asSequence)
+                        return new FailCommand(new InterpreterError("ListUnaryOperation", `Expected Sequence but got ${operand.getType()}`));
+                    return new BindCommand(this.context.lazyRuntime.realizeList(operand), (arr) => {
+                        const seq = arr.asSequence;
+                        if (!seq)
+                            return new RaiseCommand(new InterpreterError(`[${node.operator}]`, `Expected ${arr} to be a YuSequence.`));
+                        const fn = ListUnaryTable[node.operator];
+                        if (!fn)
+                            return new FailCommand(new InterpreterError("ListUnaryOperation", `Unknown operator: ${node.operator}`));
+                        return fn(seq);
+                    });
+                });
+            });
+        }
+        visitListBinaryOperation(node) {
+            if (node.operator === "Concat") {
+                const capturedCtx = this.context.clone();
+                return new BindCommand(this.evaluate(node.left), (rawLeft) => {
+                    return new BindCommand(this.context.forceValue(rawLeft), (left) => {
+                        const seqL = left.asSequence;
+                        if (!seqL)
+                            return new RaiseCommand(new InterpreterError("ListBinaryOperation", "Invalid left operand for lazy Concat"));
+                        if (this.context.config.lazyLoading) {
+                            const lazyRight = new LazyList(() => {
+                                if (!capturedCtx.evaluatorFactory)
+                                    return new RaiseCommand(new InterpreterError("ListBinaryOperation", "EvaluatorFactory not initialized in RuntimeContext"));
+                                const subEvaluator = capturedCtx.evaluatorFactory(capturedCtx);
+                                const subKernel = new YukigoKernel(subEvaluator);
+                                const rawRight = subKernel.run(new EvalCommand(node.right));
+                                const right = subKernel.run(capturedCtx.forceValue(rawRight));
+                                const seqR = right.asSequence;
+                                if (!seqR)
+                                    return new RaiseCommand(new InterpreterError("ListBinaryOperation", "Invalid right operand for lazy Concat"));
+                                return seqR.step();
+                            }, "LazyRight", capturedCtx);
+                            return this.context.lazyRuntime.evaluateConcat(seqL, lazyRight);
+                        }
+                        return new BindCommand(this.evaluate(node.right), (rawRight) => {
+                            return new BindCommand(this.context.forceValue(rawRight), (right) => {
+                                const seqR = right.asSequence;
+                                if (!seqR)
+                                    return new RaiseCommand(new InterpreterError("ListBinaryOperation", "Invalid right operand for lazy Concat"));
+                                return seqL.concat(seqR);
+                            });
+                        });
+                    });
+                });
+            }
+            return processBinary(this, node, ListBinaryTable, (a, b) => !!a.asSequence && !!b.asSequence, "ListBinaryOperation");
+        }
+        visitComparisonOperation(node) {
+            return new BindCommand(this.evaluate(node.left), (rawLeft) => {
+                return new BindCommand(this.context.forceValue(rawLeft), (left) => {
+                    return new BindCommand(this.evaluate(node.right), (rawRight) => {
+                        return new BindCommand(this.context.forceValue(rawRight), (right) => {
+                            if (node.operator === "Equal" || node.operator === "NotEqual") {
+                                return new BindCommand(EqualityComparer.compare(left, right, this.context), (eq) => {
+                                    const isEq = isTrue(eq);
+                                    return new StepCommand(new YuBoolean(node.operator === "Equal" ? isEq : !isEq));
+                                });
+                            }
+                            if (left instanceof RuntimeObject) {
+                                const objRuntime = this.context.objRuntime;
+                                const chain = objRuntime.getResolutionChain(left);
+                                const hasCompare = !!objRuntime.findMethodInChain(chain, "compare/1") ||
+                                    !!objRuntime.findMethodInChain(chain, "compare");
+                                if (hasCompare) {
+                                    return new BindCommand(this.context.objRuntime.dispatch(left, "compare", [
+                                        right,
+                                    ]), (compRes) => {
+                                        if (compRes instanceof YuNumber) {
+                                            const val = compRes.value;
+                                            let isTrue = false;
+                                            if (node.operator === "GreaterOrEqualThan")
+                                                isTrue = val >= 0;
+                                            else if (node.operator === "GreaterThan")
+                                                isTrue = val > 0;
+                                            else if (node.operator === "LessOrEqualThan")
+                                                isTrue = val <= 0;
+                                            else if (node.operator === "LessThan")
+                                                isTrue = val < 0;
+                                            return new StepCommand(new YuBoolean(isTrue));
+                                        }
+                                        return new RaiseCommand(new InterpreterError("ComparisonOperation", "compare method did not return a number"));
+                                    });
+                                }
+                            }
+                            if (!ComparisonOperationTable[node.operator]) {
+                                return new FailCommand(new InterpreterError("ComparisonOperation", `Unknown op: ${node.operator}`));
+                            }
+                            try {
+                                return ComparisonOperationTable[node.operator](left, right);
+                            }
+                            catch (error) {
+                                return new FailCommand(new InterpreterError("ComparisonOperation", error.message));
+                            }
+                        });
+                    });
+                });
+            });
+        }
+        visitLogicalBinaryOperation(node) {
+            return new BindCommand(this.evaluate(node.left), (left) => {
+                const logicValue = left.asLogic;
+                if (!logicValue)
+                    return new FailCommand(new InterpreterError("LogicalBinaryOperation", `Expected left side to be boolean and got: ${left}`));
+                if (this.context.config.lazyLoading) {
+                    if (node.operator === "And") {
+                        const val = logicValue.toJSON();
+                        if (val === false)
+                            return boolean(false);
+                    }
+                    if (node.operator === "Or") {
+                        const val = logicValue.toJSON();
+                        if (val === true)
+                            return boolean(true);
+                    }
+                }
+                const fn = LogicalBinaryTable[node.operator];
+                if (!fn)
+                    return new FailCommand(new InterpreterError("LogicalBinaryOperation", `Unknown operator '${node.operator}'`));
+                return fn(logicValue, () => this.evaluate(node.right));
+            });
+        }
+        visitLogicalUnaryOperation(node) {
+            return processUnary(this, node, LogicalUnaryTable, (a) => !!a.asLogic, "LogicalUnaryOperation");
+        }
+        visitBitwiseBinaryOperation(node) {
+            return processBinary(this, node, BitwiseBinaryTable, (a, b) => !!a.asNumeric && !!b.asNumeric, "BitwiseBinaryOperation");
+        }
+        visitBitwiseUnaryOperation(node) {
+            return processUnary(this, node, BitwiseUnaryTable, (a) => !!a.asNumeric, "BitwiseUnaryOperation");
+        }
+        visitStringOperation(node) {
+            return processBinary(this, node, StringOperationTable, (a, b) => !!a.asSummable && !!b.asSummable, "StringOperation");
+        }
+        visitUnifyOperation(node) {
+            return getLogicEngine(this, this.context).unifyExpr(node.left, node.right);
+        }
+        visitAssignOperation(node) {
+            if (!this.context.config.mutability) {
+                return raise(error("AssignOperation", `Cannot perform assignment operation: mutability is disabled`));
+            }
+            if (!(node.left instanceof SymbolPrimitive))
+                return new FailCommand(new InterpreterError("AssignOperation", "Left side must be a SymbolPrimitive"));
+            const name = node.left.value;
+            return new BindCommand(this.evaluate(node.right), (value) => {
+                const onReplace = (scope) => {
+                    if (scope.has("self")) {
+                        const self = scope.get("self");
+                        if (self instanceof RuntimeObject && self.fields.has(name)) {
+                            self.fields.set(name, value);
+                        }
+                    }
+                };
+                if (!this.context.replace(name, value, onReplace)) {
+                    this.context.define(name, value);
+                }
+                return boolean(true);
+            });
+        }
+        visitArithmeticBinaryOperation(node) {
+            const isPlus = node.operator === "Plus";
+            const summablePair = (a, b) => !!a.asSummable && !!b.asSummable;
+            const numericPair = (a, b) => !!a.asNumeric && !!b.asNumeric;
+            return processBinary(this, node, ArithmeticBinaryTable, isPlus ? summablePair : numericPair, "ArithmeticBinaryOperation");
+        }
+    };
+}

package/dist/interpreter/components/evaluators/PrimitiveEvaluator.d.ts

@@ -0,0 +1,19 @@
+import { BooleanPrimitive, CharPrimitive, ListPrimitive, NilPrimitive, NumberPrimitive, StringPrimitive, SymbolPrimitive } from "yukigo-ast";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { Constructor, EvaluatorBase } from "./BaseEvaluator.js";
+export declare function PrimitiveEvaluator<TBase extends Constructor<EvaluatorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        visitStringPrimitive(node: StringPrimitive): ExecutionCommand;
+        visitListPrimitive(node: ListPrimitive): ExecutionCommand;
+        visitNilPrimitive(node: NilPrimitive): ExecutionCommand;
+        visitSymbolPrimitive(node: SymbolPrimitive): ExecutionCommand;
+        visitCharPrimitive(node: CharPrimitive): ExecutionCommand;
+        visitNumberPrimitive(node: NumberPrimitive): ExecutionCommand;
+        visitBooleanPrimitive(node: BooleanPrimitive): ExecutionCommand;
+        context: import("../RuntimeContext.js").RuntimeContext;
+        getContext(): import("../RuntimeContext.js").RuntimeContext;
+        evaluate(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+    };
+} & TBase;

package/dist/interpreter/components/evaluators/PrimitiveEvaluator.js

@@ -0,0 +1,50 @@
+import { BindCommand, FailCommand, StepCommand, } from "../kernel/commands.js";
+import { YuArray, YuBoolean, YuNil, YuNumber, YuString, } from "../../primitives/index.js";
+import { InterpreterError } from "../../errors.js";
+export function PrimitiveEvaluator(Base) {
+    return class extends Base {
+        visitStringPrimitive(node) {
+            return new StepCommand(new YuString(node.value));
+        }
+        visitListPrimitive(node) {
+            if (node.value.length === 0)
+                return new StepCommand(new YuArray([]));
+            const results = [];
+            const evaluateNext = (index) => {
+                if (index >= node.value.length)
+                    return new StepCommand(new YuArray(results));
+                return new BindCommand(this.evaluate(node.value[index]), (val) => {
+                    results.push(val);
+                    return evaluateNext(index + 1);
+                });
+            };
+            return evaluateNext(0);
+        }
+        visitNilPrimitive(node) {
+            return new StepCommand(YuNil.getInstance());
+        }
+        visitSymbolPrimitive(node) {
+            try {
+                const isLogic = !!this.context.logicState;
+                const isVar = /^[A-Z_]/.test(node.value);
+                if (isLogic && !isVar && !this.context.isDefined(node.value)) {
+                    return new StepCommand(new YuString(node.value));
+                }
+                const val = this.context.lookup(node.value);
+                return new StepCommand(val);
+            }
+            catch (error) {
+                return new FailCommand(new InterpreterError("Symbol Lookup", error.message));
+            }
+        }
+        visitCharPrimitive(node) {
+            return new StepCommand(new YuString(node.value));
+        }
+        visitNumberPrimitive(node) {
+            return new StepCommand(new YuNumber(node.value));
+        }
+        visitBooleanPrimitive(node) {
+            return new StepCommand(new YuBoolean(node.value));
+        }
+    };
+}

package/dist/interpreter/components/evaluators/StatementEvaluator.d.ts

@@ -0,0 +1,28 @@
+import { Assignment, Attribute, Function, If, LogicConstraint, Object, Print, Query, Raise, Return, Self, Sequence, Super, Try, Variable } from "yukigo-ast";
+import { Constructor as EvaluatorConstructor, EvaluatorBase } from "./BaseEvaluator.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+export declare function StatementEvaluator<TBase extends EvaluatorConstructor<EvaluatorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        visitSequence(node: Sequence): ExecutionCommand;
+        visitSelf(node: Self): ExecutionCommand;
+        visitSuper(node: Super): ExecutionCommand;
+        visitIf(node: If): ExecutionCommand;
+        visitReturn(node: Return): ExecutionCommand;
+        visitFunction(node: Function): ExecutionCommand;
+        visitTry(node: Try): ExecutionCommand;
+        visitRaise(node: Raise): ExecutionCommand;
+        visitPrint(node: Print): ExecutionCommand;
+        visitVariable(node: Variable): ExecutionCommand;
+        visitAssignment(node: Assignment): ExecutionCommand;
+        visitQuery(node: Query): ExecutionCommand;
+        visitAttribute(node: Attribute): ExecutionCommand;
+        visitObject(node: Object): ExecutionCommand;
+        visitLogicConstraint(node: LogicConstraint): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+    };
+} & TBase;