yukigo 0.1.0 → 0.2.0

package/dist/interpreter/components/PatternMatcher.js

@@ -1,6 +1,64 @@
-import { ConstructorPattern, isLazyList, ListPrimitive, } from "@yukigo/ast";
+import { ConstructorPattern, isLazyList, ListPrimitive, SimpleType, ListType, } from "yukigo-ast";
 import { InterpreterVisitor } from "./Visitor.js";
-import { createStream } from "../utils.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;
@@ -11,7 +69,7 @@ export class PatternResolver {
     visitLiteralPattern(node) {
         const { name } = node;
         if (name instanceof ListPrimitive)
-            return String(name.elements.map((elem) => elem.accept(this)));
+            return String(name.value.map((elem) => elem.accept(this)));
         return String(name.value);
     }
     visitTuplePattern(node) {
@@ -24,28 +82,34 @@ export class PatternResolver {
             : String(elements.map((elem) => elem.accept(this)));
     }
     visitConsPattern(node) {
-        const head = node.head.accept(this);
-        const tail = node.tail.accept(this);
+        const head = node.left.accept(this);
+        const tail = node.right.accept(this);
         return `(${head}:${tail})`;
     }
     visitConstructorPattern(node) {
-        const constr = node.constr;
-        const args = node.patterns.map((pat) => pat.accept(this)).join(" ");
+        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.value, node.args));
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
     }
     visitApplicationPattern(node) {
         // Same as FunctorPattern
-        return this.visitConstructorPattern(new ConstructorPattern(node.symbol.value, node.args));
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
     }
     visitAsPattern(node) {
-        const pattern = node.pattern.accept(this);
-        const alias = node.alias.accept(this);
+        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);
     }
@@ -58,149 +122,230 @@ export class PatternResolver {
 export class PatternMatcher {
     value;
     bindings;
-    constructor(value, bindings) {
+    ctx;
+    constructor(value, bindings, ctx) {
         this.value = value;
         this.bindings = bindings;
+        this.ctx = ctx;
     }
     visitVariablePattern(node) {
-        this.bindings.push([node.name.value, this.value]);
-        return true;
+        return (k) => {
+            this.bindings.push([node.name.value, this.value]);
+            return k(true);
+        };
     }
     visitWildcardPattern(node) {
-        return true;
+        return (k) => k(true);
     }
     visitLiteralPattern(node) {
-        const literalValue = InterpreterVisitor.evaluateLiteral(node.name);
-        return this.deepEqual(this.value, literalValue);
+        return (k) => {
+            const literalValue = InterpreterVisitor.evaluateLiteral(node.name);
+            return this.ctx.lazyRuntime.deepEqual(this.value, literalValue, k);
+        };
     }
     visitTuplePattern(node) {
-        if (!Array.isArray(this.value))
-            return false;
-        if (this.value.length !== node.elements.length)
-            return false;
-        for (let i = 0; i < node.elements.length; i++) {
-            const matcher = new PatternMatcher(this.value[i], this.bindings);
-            if (!node.elements[i].accept(matcher))
-                return false;
-        }
-        return true;
+        return (k) => {
+            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);
+            };
+            if (isLazyList(this.value)) {
+                return this.ctx.lazyRuntime.realizeList(this.value, (val) => {
+                    return () => processValue(val);
+                });
+            }
+            return processValue(this.value);
+        };
     }
     visitListPattern(node) {
-        // empty list case
-        if (node.elements.length === 0) {
-            if (Array.isArray(this.value))
-                return this.value.length === 0;
-            if (isLazyList(this.value)) {
-                const iter = this.value.generator();
-                return iter.next().done;
+        return (k) => {
+            const value = this.value;
+            const neededLength = node.elements.length;
+            const finishMatching = (valArr) => {
+                if (valArr.length !== neededLength)
+                    return k(false);
+                return this.matchList(node.elements, valArr, k);
+            };
+            // 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);
+                }
+                return k(false);
             }
-            return false;
-        }
-        // finite list case
-        if (Array.isArray(this.value))
-            return this.matchList(node.elements, this.value);
-        // lazy list case
-        if (isLazyList(this.value)) {
-            const realized = this.realize(this.value);
-            return this.matchList(node.elements, realized);
-        }
-        return 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);
+                });
+            }
+            return k(false);
+        };
     }
-    matchList(elements, value) {
+    matchList(elements, value, k) {
         if (value.length !== elements.length)
-            return false;
-        for (let i = 0; i < elements.length; i++) {
-            const matcher = new PatternMatcher(value[i], this.bindings);
-            const isMatch = elements[i].accept(matcher);
-            if (!isMatch)
-                return false;
-        }
-        return true;
+            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);
     }
     visitConsPattern(node) {
-        const [head, tail] = this.resolveCons(this.value);
-        if (!head || !tail)
-            return false;
-        const headMatcher = new PatternMatcher(head, this.bindings);
-        const headMatches = node.head.accept(headMatcher);
-        if (!headMatches)
-            return false;
-        const tailMatcher = new PatternMatcher(tail, this.bindings);
-        return node.tail.accept(tailMatcher);
+        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);
+            });
+        };
+    }
+    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))
-            return list.length === 0 ? [null, null] : [list[0], list.slice(1)];
-        if (isLazyList(list)) {
-            const headIter = list.generator();
-            const next = headIter.next();
-            if (next.done)
+        if (Array.isArray(list)) {
+            if (list.length === 0)
                 return [null, null];
-            const parentGeneratorFactory = list.generator;
-            const tailGenerator = function* () {
-                const freshIter = parentGeneratorFactory();
-                freshIter.next();
-                let next;
-                while (!(next = freshIter.next()).done)
-                    yield next.value;
+            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 [next.value, createStream(tailGenerator)];
+            return [list[0], tail];
+        }
+        if (typeof list === "string") {
+            if (list.length === 0)
+                return [null, null];
+            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];
+        }
+        // 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 [null, null];
     }
     visitConstructorPattern(node) {
-        if (!Array.isArray(this.value) || this.value.length === 0)
-            return false;
-        if (this.value[0] !== node.constr)
-            return false;
-        const args = this.value.slice(1);
-        return this.matchList(node.patterns, args);
+        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);
+        };
     }
     visitFunctorPattern(node) {
-        return this.visitConstructorPattern(new ConstructorPattern(node.identifier.value, node.args));
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
     }
     visitApplicationPattern(node) {
-        return this.visitConstructorPattern(new ConstructorPattern(node.symbol.value, node.args));
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
     }
     visitAsPattern(node) {
-        const innerMatcher = new PatternMatcher(this.value, this.bindings);
-        const innerMatches = node.pattern.accept(innerMatcher);
-        if (!innerMatches)
-            return false;
-        const aliasMatcher = new PatternMatcher(this.value, this.bindings);
-        return node.alias.accept(aliasMatcher);
+        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);
+            });
+        };
     }
     visitUnionPattern(node) {
-        for (const pattern of node.patterns) {
-            const trialBindings = [];
-            const matcher = new PatternMatcher(this.value, trialBindings);
-            if (pattern.accept(matcher)) {
-                this.bindings.push(...trialBindings);
-                return true;
-            }
-        }
-        return false;
+        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);
+        };
     }
     visit(node) {
         return node.accept(this);
     }
-    deepEqual(a, b) {
-        if (a === b)
-            return true;
-        if (typeof a !== typeof b)
-            return false;
-        if (Array.isArray(a) && Array.isArray(b)) {
-            if (a.length !== b.length)
-                return false;
-            for (let i = 0; i < a.length; i++) {
-                if (!this.deepEqual(a[i], b[i]))
-                    return false;
-            }
-            return true;
-        }
-        return false;
-    }
-    realize(value) {
-        return new InterpreterVisitor([new Map()], {}).realizeList(value);
-    }
 }

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

@@ -0,0 +1,35 @@
+import { Environment, EnvStack, PrimitiveValue } from "yukigo-ast";
+import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
+export declare const DefaultConfiguration: Required<InterpreterConfig>;
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface InterpreterConfig {
+    lazyLoading?: boolean;
+    debug?: boolean;
+    outputMode?: LogicSearchMode;
+    mutability?: boolean;
+}
+export declare class UninitializedConfig extends Error {
+    constructor();
+}
+export declare class ReinitializedConfig extends Error {
+    constructor();
+}
+export declare class RuntimeContext {
+    readonly config: InterpreterConfig | null;
+    env: EnvStack;
+    lazyRuntime: LazyRuntime;
+    funcRuntime: FunctionRuntime;
+    objRuntime: ObjectRuntime;
+    constructor(config?: InterpreterConfig);
+    setEnv(env: EnvStack): void;
+    isDefined(name: string): boolean;
+    pushEnv(frame?: Environment): void;
+    replace(name: string, value: PrimitiveValue, onReplace?: (env: Environment) => void): boolean;
+    popEnv(): void;
+    lookup(name: string): PrimitiveValue;
+    remove(name: string): void;
+    define(name: string, value: PrimitiveValue): void;
+    clone(env?: EnvStack): EnvStack;
+}

package/dist/interpreter/components/RuntimeContext.js

@@ -0,0 +1,93 @@
+import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
+import { createGlobalEnv } from "../utils.js";
+import { UnboundVariable } from "../errors.js";
+export const DefaultConfiguration = {
+    lazyLoading: false,
+    debug: false,
+    outputMode: "first",
+    mutability: true,
+};
+export class UninitializedConfig extends Error {
+    constructor() {
+        super("GlobalConfig was not initialized. You must call initialize() first.");
+    }
+}
+export class ReinitializedConfig extends Error {
+    constructor() {
+        super("GlobalConfig is already initialized. You cannot change it at execution.");
+    }
+}
+export class RuntimeContext {
+    config = null;
+    env;
+    lazyRuntime;
+    funcRuntime;
+    objRuntime;
+    constructor(config) {
+        this.config = Object.freeze({ ...DefaultConfiguration, ...config });
+        this.lazyRuntime = new LazyRuntime(this);
+        this.funcRuntime = new FunctionRuntime(this);
+        this.objRuntime = new ObjectRuntime(this);
+        this.env = createGlobalEnv();
+    }
+    setEnv(env) {
+        this.env = env;
+    }
+    isDefined(name) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name))
+                return true;
+            current = current.tail;
+        }
+        return false;
+    }
+    pushEnv(frame = new Map()) {
+        this.env = {
+            head: frame,
+            tail: this.env,
+        };
+    }
+    replace(name, value, onReplace) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name)) {
+                current.head.set(name, value);
+                if (onReplace)
+                    onReplace(current.head);
+                return true;
+            }
+            current = current.tail;
+        }
+        return false;
+    }
+    popEnv() {
+        if (!this.env.tail)
+            throw new Error("Runtime Error: Cannot pop the global environment scope.");
+        this.env = this.env.tail;
+    }
+    lookup(name) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name))
+                return current.head.get(name);
+            current = current.tail;
+        }
+        throw new UnboundVariable(name);
+    }
+    remove(name) {
+        this.env.head.delete(name);
+    }
+    define(name, value) {
+        this.env.head.set(name, value);
+    }
+    clone(env) {
+        const target = env ?? this.env;
+        return {
+            head: new Map(target.head),
+            tail: this.env.tail,
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Assert, PrimitiveValue, Test, TestGroup, TraverseVisitor } from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { CPSThunk } from "../trampoline.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+export declare class FailedAssert extends Error {
+    actual?: PrimitiveValue;
+    expected?: PrimitiveValue;
+    constructor(actual?: PrimitiveValue, expected?: PrimitiveValue, message?: string);
+}
+export declare class TestRunner extends TraverseVisitor {
+    interpreter: InterpreterVisitor;
+    private lazyRuntime;
+    constructor(interpreter: InterpreterVisitor, lazyRuntime: LazyRuntime);
+    run(node: TestGroup | Test | Assert): CPSThunk<void>;
+    visitTestGroup(node: TestGroup): CPSThunk<void>;
+    visitTest(node: Test): CPSThunk<void>;
+    visitAssert(node: Assert): CPSThunk<void>;
+}