yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/PatternMatcher.d.ts

@@ -1,71 +1,32 @@
-import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, Expression, FunctorPattern, LazyList, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern, TypePattern, EnvStack } from "yukigo-ast";
+import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, FunctorPattern, ListPattern, LiteralPattern, TuplePattern, UnionPattern, VariablePattern, WildcardPattern, TypePattern } from "yukigo-ast";
 import { Bindings } from "../index.js";
-import { CPSThunk } from "../trampoline.js";
+import { ExecutionCommand } from "../components/kernel/commands.js";
 import { RuntimeContext } from "./RuntimeContext.js";
-import { ExpressionEvaluator } from "../utils.js";
-declare class SharedSequence {
-    private cache;
-    private source;
-    private isDone;
-    constructor(generatorFactory: () => Generator<PrimitiveValue, void, unknown>);
-    get(index: number): {
-        value: PrimitiveValue | null;
-        done: boolean;
-    };
-}
-export interface InternalConsState {
-    readonly head: PrimitiveValue;
-    readonly tailExpr: Expression;
-    readonly evaluator: ExpressionEvaluator;
-    readonly capturedEnv: EnvStack;
-    realizedTail?: PrimitiveValue;
-}
-export interface MemoizedLazyList extends LazyList {
-    _sequence: SharedSequence;
-    _offset: number;
-    _consState?: InternalConsState;
-    toJSON: () => any;
-}
-export declare function isMemoizedList(list: unknown): list is MemoizedLazyList;
-export declare function createMemoizedStream(genFactory: () => Generator<PrimitiveValue, void, unknown>, sequence?: SharedSequence, offset?: number): MemoizedLazyList;
-export declare class PatternResolver implements Visitor<string> {
-    visitVariablePattern(node: VariablePattern): string;
-    visitWildcardPattern(node: WildcardPattern): string;
-    visitLiteralPattern(node: LiteralPattern): string;
-    visitTuplePattern(node: TuplePattern): string;
-    visitListPattern(node: ListPattern): string;
-    visitConsPattern(node: ConsPattern): string;
-    visitConstructorPattern(node: ConstructorPattern): string;
-    visitFunctorPattern(node: FunctorPattern): string;
-    visitApplicationPattern(node: ApplicationPattern): string;
-    visitAsPattern(node: AsPattern): string;
-    visitTypePattern(node: TypePattern): string;
-    visit(node: ASTNode): string;
-}
+import { YuValue } from "../primitives/index.js";
 /**
  * Recursively matches a value against a pattern node.
  * Updates `bindings` when variables are bound successfully.
  * Returns true if the pattern matches, false otherwise.
  */
-export declare class PatternMatcher implements Visitor<CPSThunk<boolean>> {
+export declare class PatternMatcher {
     private value;
     private bindings;
     private ctx;
-    constructor(value: PrimitiveValue, bindings: Bindings, ctx: RuntimeContext);
-    visitVariablePattern(node: VariablePattern): CPSThunk<boolean>;
-    visitWildcardPattern(node: WildcardPattern): CPSThunk<boolean>;
-    visitLiteralPattern(node: LiteralPattern): CPSThunk<boolean>;
-    visitTuplePattern(node: TuplePattern): CPSThunk<boolean>;
-    visitListPattern(node: ListPattern): CPSThunk<boolean>;
+    constructor(value: YuValue, bindings: Bindings, ctx: RuntimeContext);
+    visitVariablePattern(node: VariablePattern): ExecutionCommand;
+    visitWildcardPattern(node: WildcardPattern): ExecutionCommand;
+    visitLiteralPattern(node: LiteralPattern): ExecutionCommand;
+    visitTuplePattern(node: TuplePattern): ExecutionCommand;
+    visitListPattern(node: ListPattern): ExecutionCommand;
     private matchList;
-    visitConsPattern(node: ConsPattern): CPSThunk<boolean>;
-    visitTypePattern(node: TypePattern): CPSThunk<boolean>;
+    visitConsPattern(node: ConsPattern): ExecutionCommand;
+    visitTypePattern(node: TypePattern): ExecutionCommand;
     private resolveCons;
-    visitConstructorPattern(node: ConstructorPattern): CPSThunk<boolean>;
-    visitFunctorPattern(node: FunctorPattern): CPSThunk<boolean>;
-    visitApplicationPattern(node: ApplicationPattern): CPSThunk<boolean>;
-    visitAsPattern(node: AsPattern): CPSThunk<boolean>;
-    visitUnionPattern(node: UnionPattern): CPSThunk<boolean>;
-    visit(node: ASTNode): CPSThunk<boolean>;
+    visitConstructorPattern(node: ConstructorPattern): ExecutionCommand;
+    visitFunctorPattern(node: FunctorPattern): ExecutionCommand;
+    visitApplicationPattern(node: ApplicationPattern): ExecutionCommand;
+    visitAsPattern(node: AsPattern): ExecutionCommand;
+    visitUnionPattern(node: UnionPattern): ExecutionCommand;
+    visit(node: ASTNode): ExecutionCommand;
+    fallback(node: ASTNode): ExecutionCommand;
 }
-export {};

package/dist/interpreter/components/PatternMatcher.js

@@ -1,119 +1,9 @@
-import { ConstructorPattern, isLazyList, ListPrimitive, SimpleType, ListType, } from "yukigo-ast";
-import { InterpreterVisitor } from "./Visitor.js";
-import { getYukigoType } from "../utils.js";
-class SharedSequence {
-    cache = [];
-    source;
-    isDone = false;
-    constructor(generatorFactory) {
-        this.source = generatorFactory();
-    }
-    get(index) {
-        if (index < this.cache.length)
-            return { value: this.cache[index], done: false };
-        if (this.isDone)
-            return { value: null, done: true };
-        while (this.cache.length <= index) {
-            const next = this.source.next();
-            if (next.done) {
-                this.isDone = true;
-                return { value: null, done: true };
-            }
-            this.cache.push(next.value);
-        }
-        return { value: this.cache[index], done: false };
-    }
-}
-export function isMemoizedList(list) {
-    return (list &&
-        typeof list === "object" &&
-        "type" in list &&
-        "_offset" in list &&
-        "_sequence" in list);
-}
-export function createMemoizedStream(genFactory, sequence, offset = 0) {
-    const seq = sequence ?? new SharedSequence(genFactory);
-    return {
-        type: "LazyList",
-        _sequence: seq,
-        _offset: offset,
-        generator: function* () {
-            let currentIdx = offset;
-            while (true) {
-                const res = seq.get(currentIdx);
-                if (res.done)
-                    return;
-                yield res.value;
-                currentIdx++;
-            }
-        },
-        toJSON() {
-            const iterator = this.generator();
-            const buffer = [];
-            let next = iterator.next();
-            while (!next.done) {
-                buffer.push(next.value);
-                next = iterator.next();
-            }
-            return buffer;
-        },
-    };
-}
-export class PatternResolver {
-    visitVariablePattern(node) {
-        return node.name.value;
-    }
-    visitWildcardPattern(node) {
-        return "_";
-    }
-    visitLiteralPattern(node) {
-        const { name } = node;
-        if (name instanceof ListPrimitive)
-            return String(name.value.map((elem) => elem.accept(this)));
-        return String(name.value);
-    }
-    visitTuplePattern(node) {
-        return String(node.elements.map((elem) => elem.accept(this)));
-    }
-    visitListPattern(node) {
-        const { elements } = node;
-        return elements.length === 0
-            ? "[]"
-            : String(elements.map((elem) => elem.accept(this)));
-    }
-    visitConsPattern(node) {
-        const head = node.left.accept(this);
-        const tail = node.right.accept(this);
-        return `(${head}:${tail})`;
-    }
-    visitConstructorPattern(node) {
-        const constr = node.identifier.value;
-        const args = node.args.map((pat) => pat.accept(this)).join(" ");
-        return `${constr} ${args}`;
-    }
-    visitFunctorPattern(node) {
-        // Same as ConstructorPattern (alias)
-        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
-    }
-    visitApplicationPattern(node) {
-        // Same as FunctorPattern
-        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
-    }
-    visitAsPattern(node) {
-        const alias = node.left.accept(this);
-        const pattern = node.right.accept(this);
-        return `${alias}@${pattern}`;
-    }
-    visitTypePattern(node) {
-        const typeStr = node.targetType.toString();
-        return node.innerPattern
-            ? `(${typeStr} ${node.innerPattern.accept(this)})`
-            : typeStr;
-    }
-    visit(node) {
-        return node.accept(this);
-    }
-}
+import { ConstructorPattern, SimpleType, ListType, } from "yukigo-ast";
+import { StepCommand, BindCommand, FailCommand, RaiseCommand, } from "../components/kernel/commands.js";
+import { boolean, getYukigoType } from "../utils.js";
+import { InterpreterError, UnexpectedNode } from "../errors.js";
+import { EqualityComparer } from "./EqualityComparer.js";
+import { YuBoolean, YuArray, isLazyList, YuNil, YuString, LazyList, LazyStepResult, YuChar, } from "../primitives/index.js";
 /**
  * Recursively matches a value against a pattern node.
  * Updates `bindings` when variables are bound successfully.
@@ -129,185 +19,193 @@ export class PatternMatcher {
         this.ctx = ctx;
     }
     visitVariablePattern(node) {
-        return (k) => {
-            this.bindings.push([node.name.value, this.value]);
-            return k(true);
-        };
+        this.bindings.push([node.name.value, this.value]);
+        return boolean(true);
     }
     visitWildcardPattern(node) {
-        return (k) => k(true);
+        return boolean(true);
     }
     visitLiteralPattern(node) {
-        return (k) => {
-            const literalValue = InterpreterVisitor.evaluateLiteral(node.name);
-            return this.ctx.lazyRuntime.deepEqual(this.value, literalValue, k);
-        };
+        return new BindCommand(this.ctx.forceValue(this.value), (val) => {
+            const visitor = this.ctx.evaluatorFactory(this.ctx);
+            const VisitorClass = visitor.constructor;
+            const literalValue = VisitorClass.evaluateLiteral(node.name, this.ctx);
+            return EqualityComparer.compare(val, literalValue, this.ctx);
+        });
     }
     visitTuplePattern(node) {
-        return (k) => {
+        return new BindCommand(this.ctx.forceValue(this.value), (forcedVal) => {
             const processValue = (val) => {
-                if (!Array.isArray(val))
-                    return k(false);
-                if (val.length !== node.elements.length)
-                    return k(false);
-                const matchNext = (index) => {
-                    if (index >= node.elements.length)
-                        return k(true);
-                    const matcher = new PatternMatcher(val[index], this.bindings, this.ctx);
-                    return node.elements[index].accept(matcher)((isMatch) => {
-                        if (!isMatch)
-                            return k(false);
-                        return () => matchNext(index + 1);
-                    });
-                };
-                return matchNext(0);
+                const seq = val.asSequence;
+                if (!(seq instanceof YuArray))
+                    return boolean(false);
+                if (seq.items.length !== node.elements.length)
+                    return boolean(false);
+                return this.matchList(node.elements, seq, 0);
             };
-            if (isLazyList(this.value)) {
-                return this.ctx.lazyRuntime.realizeList(this.value, (val) => {
-                    return () => processValue(val);
-                });
+            const valSeq = forcedVal.asSequence;
+            if (valSeq && isLazyList(valSeq)) {
+                return new BindCommand(this.ctx.lazyRuntime.realizeList(forcedVal), processValue);
             }
-            return processValue(this.value);
-        };
+            return processValue(forcedVal);
+        });
     }
     visitListPattern(node) {
-        return (k) => {
-            const value = this.value;
+        return new BindCommand(this.ctx.forceValue(this.value), (value) => {
             const neededLength = node.elements.length;
             const finishMatching = (valArr) => {
-                if (valArr.length !== neededLength)
-                    return k(false);
-                return this.matchList(node.elements, valArr, k);
+                const seq = valArr.asSequence;
+                if (!(seq instanceof YuArray))
+                    return new RaiseCommand(new InterpreterError("[PatternMatcher]", `Expected ${valArr} to be a list.`));
+                if (seq.items.length !== neededLength)
+                    return boolean(false);
+                return this.matchList(node.elements, seq, 0);
             };
-            // empty list case
             if (neededLength === 0) {
-                if (Array.isArray(value) || typeof value === "string")
-                    return k(value.length === 0);
-                if (isLazyList(value)) {
-                    const iter = value.generator();
-                    return k(iter.next().done);
+                if (value instanceof YuNil)
+                    return boolean(true);
+                const seq = value.asSequence;
+                if (seq) {
+                    if (seq instanceof YuArray || seq instanceof YuString) {
+                        return new StepCommand(new YuBoolean(seq.toJSON().length === 0));
+                    }
+                    if (isLazyList(seq)) {
+                        return new BindCommand(seq.step(), (res) => boolean(res instanceof YuNil));
+                    }
                 }
-                return k(false);
+                return boolean(false);
             }
-            if (Array.isArray(value))
-                return finishMatching(value);
-            if (typeof value === "string")
-                return finishMatching(value.split(""));
-            if (isLazyList(value)) {
-                return this.ctx.lazyRuntime.realizeList(value, (valArr) => {
-                    return () => finishMatching(valArr);
-                });
+            if (value instanceof YuNil)
+                return boolean(false);
+            const seq = value.asSequence;
+            if (seq) {
+                if (seq instanceof YuArray)
+                    return finishMatching(value);
+                if (seq instanceof YuString)
+                    return new BindCommand(seq.split(), (splitted) => finishMatching(splitted));
+                if (isLazyList(seq)) {
+                    return new BindCommand(this.ctx.lazyRuntime.realizeList(value), finishMatching);
+                }
             }
-            return k(false);
-        };
-    }
-    matchList(elements, value, k) {
-        if (value.length !== elements.length)
-            return k(false);
-        const matchNext = (index) => {
-            if (index >= elements.length)
-                return k(true);
-            const matcher = new PatternMatcher(value[index], this.bindings, this.ctx);
-            return elements[index].accept(matcher)((isMatch) => {
-                if (!isMatch)
-                    return k(false);
-                return () => matchNext(index + 1);
-            });
-        };
-        return matchNext(0);
+            return boolean(false);
+        });
+    }
+    matchList(elements, value, index) {
+        if (index >= elements.length)
+            return boolean(true);
+        const matcher = new PatternMatcher(value.at(index), this.bindings, this.ctx);
+        return new BindCommand(elements[index].accept(matcher), (res) => {
+            const isMatch = res instanceof YuBoolean && res.value;
+            if (!isMatch)
+                return boolean(false);
+            return this.matchList(elements, value, index + 1);
+        });
     }
     visitConsPattern(node) {
-        return (k) => {
-            const [head, tail] = this.resolveCons(this.value);
-            if (head === null || tail === null)
-                return k(false);
-            const headMatcher = new PatternMatcher(head, this.bindings, this.ctx);
-            return node.left.accept(headMatcher)((headMatches) => {
-                if (!headMatches)
-                    return k(false);
-                const tailMatcher = new PatternMatcher(tail, this.bindings, this.ctx);
-                return node.right.accept(tailMatcher)(k);
+        return new BindCommand(this.ctx.forceValue(this.value), (forcedVal) => {
+            return new BindCommand(this.resolveCons(forcedVal), (resolved) => {
+                if (!(resolved instanceof YuArray) || resolved.items.length !== 2)
+                    return boolean(false);
+                const head = resolved.at(0);
+                const tail = resolved.at(1);
+                const headMatcher = new PatternMatcher(head, this.bindings, this.ctx);
+                return new BindCommand(node.left.accept(headMatcher), (headRes) => {
+                    const headMatches = headRes instanceof YuBoolean && headRes.value;
+                    if (!headMatches)
+                        return boolean(false);
+                    const tailMatcher = new PatternMatcher(tail, this.bindings, this.ctx);
+                    return node.right.accept(tailMatcher);
+                });
             });
-        };
+        });
     }
     visitTypePattern(node) {
-        return (k) => {
-            const actualType = getYukigoType(this.value);
-            let matches = false;
-            const targetType = node.targetType;
-            if (targetType instanceof SimpleType) {
-                matches = targetType.value === actualType;
-            }
-            else if (targetType instanceof ListType) {
-                matches = actualType === "YuList";
-            }
-            if (!matches)
-                return k(false);
-            if (node.innerPattern) {
-                const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
-                return node.innerPattern.accept(innerMatcher)(k);
-            }
-            return k(true);
-        };
-    }
-    resolveCons(list) {
-        if (Array.isArray(list)) {
-            if (list.length === 0)
-                return [null, null];
+        const actualType = getYukigoType(this.value);
+        let matches = false;
+        const targetType = node.targetType;
+        if (targetType instanceof SimpleType) {
+            matches = targetType.value === actualType;
+        }
+        else if (targetType instanceof ListType) {
+            matches =
+                actualType === "List" ||
+                    actualType === "Array" ||
+                    actualType === "String";
+        }
+        if (!matches)
+            return boolean(false);
+        if (node.innerPattern) {
+            const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+            return node.innerPattern.accept(innerMatcher);
+        }
+        return boolean(true);
+    }
+    resolveCons(val) {
+        const list = val.asSequence;
+        if (!list)
+            return new StepCommand(YuNil.getInstance());
+        if (list instanceof YuArray) {
+            if (list.items.length === 0)
+                return new StepCommand(YuNil.getInstance());
             const isLazy = this.ctx.config.lazyLoading;
             if (!isLazy)
-                return [list[0], list.slice(1)];
-            const tail = {
-                type: "LazyList",
-                generator: function* () {
-                    for (let i = 1; i < list.length; i++)
-                        yield list[i];
-                },
-            };
-            return [list[0], tail];
+                return new StepCommand(new YuArray([
+                    list.at(0),
+                    new YuArray(list.items.slice(list.index + 1)),
+                ]));
+            const tail = new LazyList(() => {
+                const next = (arr, idx) => {
+                    if (idx >= arr.items.length)
+                        return new StepCommand(YuNil.getInstance());
+                    return new StepCommand(new LazyStepResult(arr.items[idx], new LazyList(() => next(arr, idx + 1))));
+                };
+                return next(list, list.index + 1);
+            });
+            const arr = new YuArray([list.at(0), tail]);
+            return new StepCommand(arr);
         }
-        if (typeof list === "string") {
-            if (list.length === 0)
-                return [null, null];
+        if (list instanceof YuString) {
+            const s = list.toJSON();
+            if (s.length === 0)
+                return new StepCommand(YuNil.getInstance());
             const isLazy = this.ctx.config.lazyLoading;
             if (!isLazy)
-                return [list[0], list.slice(1)];
-            const tail = {
-                type: "LazyList",
-                generator: function* () {
-                    for (let i = 1; i < list.length; i++)
-                        yield list[i];
-                },
-            };
-            return [list[0], tail];
+                return new StepCommand(new YuArray([new YuString(s[0]), new YuString(s.slice(1))]));
+            const tail = new LazyList(() => {
+                const next = (str, idx) => {
+                    if (idx >= str.length)
+                        return new StepCommand(YuNil.getInstance());
+                    return new StepCommand(new LazyStepResult(new YuChar(str[idx]), new LazyList(() => next(str, idx + 1))));
+                };
+                return next(s, 1);
+            });
+            return new StepCommand(new YuArray([new YuChar(s[0]), tail]));
         }
         // lazy list case
         if (isLazyList(list)) {
-            let memoList;
-            // optimize, convert to memoized
-            if (isMemoizedList(list)) {
-                memoList = list;
-            }
-            else {
-                memoList = createMemoizedStream(list.generator);
-            }
-            const currentRes = memoList._sequence.get(memoList._offset);
-            if (currentRes.done)
-                return [null, null];
-            const tail = createMemoizedStream(list.generator, memoList._sequence, memoList._offset + 1);
-            return [currentRes.value, tail];
+            return new BindCommand(list.step(), (stepRes) => {
+                if (stepRes.isNil)
+                    return new StepCommand(YuNil.getInstance());
+                const stepResult = stepRes.asStepResult;
+                if (!stepResult)
+                    return new RaiseCommand(new InterpreterError("PatternMatcher", "step did not return StepResult"));
+                return new StepCommand(new YuArray([
+                    stepResult.head,
+                    stepResult.tail || YuNil.getInstance(),
+                ]));
+            });
         }
-        return [null, null];
+        return new StepCommand(YuNil.getInstance());
     }
     visitConstructorPattern(node) {
-        return (k) => {
-            if (!Array.isArray(this.value) || this.value.length === 0)
-                return k(false);
-            if (this.value[0] !== node.identifier.value)
-                return k(false);
-            const args = this.value.slice(1);
-            return this.matchList(node.args, args, k);
-        };
+        const seq = this.value.asSequence;
+        if (!(seq instanceof YuArray) || seq.items.length === 0)
+            return boolean(false);
+        const head = seq.at(0);
+        if (!(head instanceof YuString) || head.toJSON() !== node.identifier.value)
+            return boolean(false);
+        const args = new YuArray(seq.items.slice(seq.index + 1));
+        return this.matchList(node.args, args, 0);
     }
     visitFunctorPattern(node) {
         return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
@@ -316,36 +214,37 @@ export class PatternMatcher {
         return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
     }
     visitAsPattern(node) {
-        return (k) => {
-            const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
-            return node.right.accept(innerMatcher)((innerMatches) => {
-                if (!innerMatches)
-                    return k(false);
-                const aliasMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
-                return node.left.accept(aliasMatcher)(k);
-            });
-        };
+        const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+        return new BindCommand(node.right.accept(innerMatcher), (res) => {
+            const innerMatches = res instanceof YuBoolean && res.value;
+            if (!innerMatches)
+                return boolean(false);
+            const aliasMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+            return node.left.accept(aliasMatcher);
+        });
     }
     visitUnionPattern(node) {
-        return (k) => {
-            const tryNext = (index) => {
-                if (index >= node.elements.length)
-                    return k(false);
-                const pattern = node.elements[index];
-                const trialBindings = [];
-                const matcher = new PatternMatcher(this.value, trialBindings, this.ctx);
-                return pattern.accept(matcher)((isMatch) => {
-                    if (isMatch) {
-                        this.bindings.push(...trialBindings);
-                        return k(true);
-                    }
-                    return () => tryNext(index + 1);
-                });
-            };
-            return tryNext(0);
+        const tryNext = (index) => {
+            if (index >= node.elements.length)
+                return boolean(false);
+            const pattern = node.elements[index];
+            const trialBindings = [];
+            const matcher = new PatternMatcher(this.value, trialBindings, this.ctx);
+            return new BindCommand(pattern.accept(matcher), (res) => {
+                const isMatch = res instanceof YuBoolean && res.value;
+                if (isMatch) {
+                    this.bindings.push(...trialBindings);
+                    return boolean(true);
+                }
+                return tryNext(index + 1);
+            });
         };
+        return tryNext(0);
     }
     visit(node) {
         return node.accept(this);
     }
+    fallback(node) {
+        return new FailCommand(new UnexpectedNode(node.constructor.name, "PatternMatcher"));
+    }
 }