yukigo 0.1.0 → 0.2.0

package/dist/analyzer/inspections/logic.js

@@ -1,140 +0,0 @@
-import { AssignOperation, Exist, StopTraversalException, SymbolPrimitive, TraverseVisitor, } from "@yukigo/ast";
-import { executeVisitor } from "../utils.js";
-import { isYukigoPrimitive } from "@yukigo/ast";
-export class DeclaresBinding extends TraverseVisitor {
-    targetBinding;
-    constructor(binding) {
-        super();
-        this.targetBinding = binding;
-    }
-}
-export class DeclaresFact extends DeclaresBinding {
-    visitFact(node) {
-        const bindingName = node.identifier.value;
-        if (!this.targetBinding || bindingName === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresRule extends DeclaresBinding {
-    visitRule(node) {
-        const bindingName = node.identifier.value;
-        if (!this.targetBinding || bindingName === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresPredicate extends DeclaresBinding {
-    visitFact(node) {
-        new DeclaresFact(this.targetBinding).visitFact(node);
-    }
-    visitRule(node) {
-        new DeclaresRule(this.targetBinding).visitRule(node);
-    }
-}
-export class PredicateVisitor extends TraverseVisitor {
-    targetBinding;
-    isInsideTargetScope = false; // this flag helps to check nested functions inside the targetBinding scope
-    constructor(binding) {
-        super();
-        this.targetBinding = binding;
-    }
-    visitFact(node) {
-        const nodeName = node.identifier.value;
-        if (!this.isInsideTargetScope) {
-            if (nodeName === this.targetBinding) {
-                this.isInsideTargetScope = true;
-                this.traverseCollection(node.patterns);
-                this.isInsideTargetScope = false;
-            }
-            return;
-        }
-        this.traverseCollection(node.patterns);
-    }
-    visitRule(node) {
-        const nodeName = node.identifier.value;
-        if (!this.isInsideTargetScope) {
-            if (nodeName === this.targetBinding) {
-                this.isInsideTargetScope = true;
-                this.traverseCollection(node.expressions);
-                this.isInsideTargetScope = false;
-            }
-            return;
-        }
-        this.traverseCollection(node.expressions);
-    }
-}
-export class UsesFindall extends TraverseVisitor {
-    visitFindall(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesForall extends TraverseVisitor {
-    visitForall(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesNot extends TraverseVisitor {
-    visitNot(node) {
-        throw new StopTraversalException();
-    }
-    visitExist(node) {
-        if (node.identifier.value === "not")
-            throw new StopTraversalException();
-    }
-}
-export class UsesUnificationOperator extends PredicateVisitor {
-    visitUnifyOperation(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesCut extends PredicateVisitor {
-    visitExist(node) {
-        if (node.identifier.value === "!")
-            throw new StopTraversalException();
-    }
-}
-export class UsesFail extends PredicateVisitor {
-    visitExist(node) {
-        if (node.identifier.value === "fail")
-            throw new StopTraversalException();
-    }
-}
-export class HasRedundantReduction extends TraverseVisitor {
-    targetBinding;
-    isInsideTargetScope = false;
-    constructor(binding) {
-        super();
-        this.targetBinding = binding;
-    }
-    visitRule(node) {
-        // Only inspect the specified rule if a binding is provided
-        if (this.targetBinding && node.identifier.value !== this.targetBinding)
-            return;
-        // Check each unification in the rule's body
-        for (const bodyElement of node.expressions) {
-            if (bodyElement instanceof AssignOperation) {
-                const left = bodyElement.left;
-                const right = bodyElement.right;
-                if (!(left instanceof SymbolPrimitive))
-                    continue;
-                const redundantReductionParameters = isYukigoPrimitive(right);
-                const redundantReductionFunctors = right instanceof Exist;
-                // Check if reduction is redundant
-                const isRedundant = redundantReductionParameters || redundantReductionFunctors;
-                if (isRedundant)
-                    throw new StopTraversalException();
-            }
-        }
-    }
-}
-export const logicInspections = {
-    DeclaresFact: (node, args, binding) => executeVisitor(node, new DeclaresFact(binding)),
-    DeclaresRule: (node, args, binding) => executeVisitor(node, new DeclaresRule(binding)),
-    DeclaresPredicate: (node, args, binding) => executeVisitor(node, new DeclaresPredicate(binding)),
-    UsesFindall: (node, args, binding) => executeVisitor(node, new UsesFindall()),
-    UsesForall: (node, args, binding) => executeVisitor(node, new UsesForall()),
-    UsesNot: (node, args, binding) => executeVisitor(node, new UsesNot()),
-    UsesUnificationOperator: (node, args, binding) => executeVisitor(node, new UsesUnificationOperator(binding)),
-    UsesCut: (node, args, binding) => executeVisitor(node, new UsesCut(binding)),
-    UsesFail: (node, args, binding) => executeVisitor(node, new UsesFail(binding)),
-    HasRedundantReduction: (node, args, binding) => executeVisitor(node, new HasRedundantReduction(binding)),
-};

package/dist/analyzer/inspections/object.d.ts

@@ -1,83 +0,0 @@
-import { Attribute, Class, Include, Interface, Method, New, Object, PrimitiveMethod, Send, TraverseVisitor } from "@yukigo/ast";
-import { InspectionMap } from "../utils.js";
-export declare class DeclaresAttribute extends TraverseVisitor {
-    private attributeName;
-    constructor(attributeName: string);
-    visitAttribute(node: Attribute): void;
-}
-export declare class DeclaresClass extends TraverseVisitor {
-    private className;
-    constructor(className: string);
-    visitClass(node: Class): void;
-}
-export declare class DeclaresInterface extends TraverseVisitor {
-    private interfaceName;
-    constructor(interfaceName: string);
-    visitInterface(node: Interface): void;
-}
-export declare class DeclaresMethod extends TraverseVisitor {
-    private methodName;
-    constructor(methodName: string);
-    visitMethod(node: Method): void;
-}
-export declare class DeclaresObject extends TraverseVisitor {
-    private objectName;
-    constructor(objectName: string);
-    visitObject(node: Object): void;
-}
-export declare class DeclaresPrimitive extends TraverseVisitor {
-    private operatorName;
-    constructor(operatorName: string);
-    visitPrimitiveMethod(node: PrimitiveMethod): void;
-}
-export declare class DeclaresSuperclass extends TraverseVisitor {
-    private superclassName;
-    constructor(superclassName: string);
-    visitClass(node: Class): void;
-}
-export declare class Implements extends TraverseVisitor {
-    private interfaceName;
-    constructor(interfaceName: string);
-    visitClass(node: Class): void;
-}
-export declare class IncludeMixin extends TraverseVisitor {
-    private mixinsName;
-    constructor(mixinsName: string);
-    visitInclude(node: Include): void;
-}
-export declare class Instantiates extends TraverseVisitor {
-    private className;
-    constructor(className: string);
-    visitNew(node: New): void;
-}
-export declare class UsesDynamicPolymorphism extends TraverseVisitor {
-    private selectorName;
-    private count;
-    constructor(selectorName: string);
-    visitMethod(node: Method): void;
-}
-export declare class UsesInheritance extends TraverseVisitor {
-    visitClass(node: Class): void;
-    visitInterface(node: Interface): void;
-}
-export declare class UsesMixins extends TraverseVisitor {
-    visitInclude(node: Include): void;
-}
-export declare class UsesObjectComposition extends TraverseVisitor {
-    visitAttribute(node: Attribute): void;
-}
-export declare class UsesStaticMethodOverload extends TraverseVisitor {
-    private scopes;
-    visitClass(node: Class): void;
-    visitObject(node: Object): void;
-    visitMethod(node: Method): void;
-}
-export declare class UsesDynamicMethodOverload extends TraverseVisitor {
-    visitMethod(node: Method): void;
-}
-export declare class UsesTemplateMethod extends TraverseVisitor {
-    private abstractMethodsStack;
-    visitClass(node: Class): void;
-    visitSend(node: Send): void;
-}
-export declare const objectInspections: InspectionMap;

package/dist/analyzer/inspections/object.js

@@ -1,235 +0,0 @@
-import { New, Self, StopTraversalException, SymbolPrimitive, TraverseVisitor, } from "@yukigo/ast";
-import { executeVisitor } from "../utils.js";
-export class DeclaresAttribute extends TraverseVisitor {
-    attributeName;
-    constructor(attributeName) {
-        super();
-        this.attributeName = attributeName;
-    }
-    visitAttribute(node) {
-        if (node.identifier.value === this.attributeName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresClass extends TraverseVisitor {
-    className;
-    constructor(className) {
-        super();
-        this.className = className;
-    }
-    visitClass(node) {
-        if (node.identifier.value === this.className)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresInterface extends TraverseVisitor {
-    interfaceName;
-    constructor(interfaceName) {
-        super();
-        this.interfaceName = interfaceName;
-    }
-    visitInterface(node) {
-        if (node.identifier.value === this.interfaceName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresMethod extends TraverseVisitor {
-    methodName;
-    constructor(methodName) {
-        super();
-        this.methodName = methodName;
-    }
-    visitMethod(node) {
-        if (node.identifier.value === this.methodName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresObject extends TraverseVisitor {
-    objectName;
-    constructor(objectName) {
-        super();
-        this.objectName = objectName;
-    }
-    visitObject(node) {
-        if (node.identifier.value === this.objectName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresPrimitive extends TraverseVisitor {
-    operatorName;
-    constructor(operatorName) {
-        super();
-        this.operatorName = operatorName;
-    }
-    visitPrimitiveMethod(node) {
-        if (node.operator === this.operatorName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresSuperclass extends TraverseVisitor {
-    superclassName;
-    constructor(superclassName) {
-        super();
-        this.superclassName = superclassName;
-    }
-    visitClass(node) {
-        if (node.extendsSymbol && node.extendsSymbol.value === this.superclassName)
-            throw new StopTraversalException();
-    }
-}
-export class Implements extends TraverseVisitor {
-    interfaceName;
-    constructor(interfaceName) {
-        super();
-        this.interfaceName = interfaceName;
-    }
-    visitClass(node) {
-        if (node.implementsNode &&
-            node.implementsNode.identifier.value === this.interfaceName)
-            throw new StopTraversalException();
-    }
-}
-export class IncludeMixin extends TraverseVisitor {
-    mixinsName;
-    constructor(mixinsName) {
-        super();
-        this.mixinsName = mixinsName;
-    }
-    visitInclude(node) {
-        if (node.identifier.value === this.mixinsName)
-            throw new StopTraversalException();
-    }
-}
-export class Instantiates extends TraverseVisitor {
-    className;
-    constructor(className) {
-        super();
-        this.className = className;
-    }
-    visitNew(node) {
-        if (node.identifier.value === this.className)
-            throw new StopTraversalException();
-    }
-}
-export class UsesDynamicPolymorphism extends TraverseVisitor {
-    selectorName;
-    count = 0;
-    constructor(selectorName) {
-        super();
-        this.selectorName = selectorName;
-    }
-    visitMethod(node) {
-        if (node.identifier.value === this.selectorName) {
-            this.count++;
-            if (this.count >= 2)
-                throw new StopTraversalException();
-        }
-    }
-}
-export class UsesInheritance extends TraverseVisitor {
-    visitClass(node) {
-        if (node.extendsSymbol)
-            throw new StopTraversalException();
-    }
-    visitInterface(node) {
-        if (node.extendsSymbol && node.extendsSymbol.length > 0)
-            throw new StopTraversalException();
-    }
-}
-export class UsesMixins extends TraverseVisitor {
-    visitInclude(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesObjectComposition extends TraverseVisitor {
-    visitAttribute(node) {
-        if (node.expression instanceof New)
-            throw new StopTraversalException();
-    }
-}
-export class UsesStaticMethodOverload extends TraverseVisitor {
-    scopes = [];
-    visitClass(node) {
-        this.scopes.push(new Set());
-        node.expression.accept(this);
-        this.scopes.pop();
-    }
-    visitObject(node) {
-        this.scopes.push(new Set());
-        node.expression.accept(this);
-        this.scopes.pop();
-    }
-    visitMethod(node) {
-        const currentScope = this.scopes[0];
-        const methodName = node.identifier.value;
-        if (currentScope.has(methodName))
-            throw new StopTraversalException();
-        currentScope.add(methodName);
-    }
-}
-export class UsesDynamicMethodOverload extends TraverseVisitor {
-    visitMethod(node) {
-        if (node.equations.length > 1)
-            throw new StopTraversalException();
-    }
-}
-class AbstractMethodCollector extends TraverseVisitor {
-    abstractMethods = new Set();
-    visitMethod(node) {
-        if (node.getMetadata("isAbstract") === true)
-            this.abstractMethods.add(node.identifier.value);
-    }
-    // stop propagation to not mix scopes
-    visitClass(node) {
-        return;
-    }
-    visitObject(node) {
-        return;
-    }
-}
-export class UsesTemplateMethod extends TraverseVisitor {
-    abstractMethodsStack = [];
-    visitClass(node) {
-        const collector = new AbstractMethodCollector();
-        if (node.expression)
-            executeVisitor(node.expression, collector);
-        this.abstractMethodsStack.push(collector.abstractMethods);
-        node.expression.accept(this);
-        this.abstractMethodsStack.pop();
-    }
-    visitSend(node) {
-        if (node.receiver instanceof Self) {
-            if (this.abstractMethodsStack.length === 0)
-                return;
-            const currentAbstractMethods = this.abstractMethodsStack[0];
-            // This doesnt match if message is complex expression
-            if (!(node.selector instanceof SymbolPrimitive))
-                return;
-            const selectorName = node.selector.value;
-            const isMessageAbstract = currentAbstractMethods.has(selectorName);
-            if (isMessageAbstract)
-                throw new StopTraversalException();
-        }
-    }
-}
-export const objectInspections = {
-    DeclaresAttribute: (node, args) => executeVisitor(node, new DeclaresAttribute(args[0])),
-    DeclaresClass: (node, args) => executeVisitor(node, new DeclaresClass(args[0])),
-    DeclaresInterface: (node, args) => executeVisitor(node, new DeclaresInterface(args[0])),
-    DeclaresMethod: (node, args) => executeVisitor(node, new DeclaresMethod(args[0])),
-    DeclaresObject: (node, args) => executeVisitor(node, new DeclaresObject(args[0])),
-    DeclaresPrimitive: (node, args) => executeVisitor(node, new DeclaresPrimitive(args[0])),
-    DeclaresSuperclass: (node, args) => executeVisitor(node, new DeclaresSuperclass(args[0])),
-    Implements: (node, args) => executeVisitor(node, new Implements(args[0])),
-    Include: (node, args) => executeVisitor(node, new IncludeMixin(args[0])),
-    Inherits: (node, args) => executeVisitor(node, new DeclaresSuperclass(args[0])),
-    Instantiates: (node, args) => executeVisitor(node, new Instantiates(args[0])),
-    UsesDynamicPolymorphism: (node, args) => executeVisitor(node, new UsesDynamicPolymorphism(args[0])),
-    UsesInheritance: (node, args) => executeVisitor(node, new UsesInheritance()),
-    UsesMixins: (node, args) => executeVisitor(node, new UsesMixins()),
-    UsesObjectComposition: (node, args) => executeVisitor(node, new UsesObjectComposition()),
-    UsesStaticMethodOverload: (node, args) => executeVisitor(node, new UsesStaticMethodOverload()),
-    UsesDynamicMethodOverload: (node, args) => executeVisitor(node, new UsesDynamicMethodOverload()),
-    UsesTemplateMethod: (node, args) => executeVisitor(node, new UsesTemplateMethod()),
-    UsesStaticPolymorphism: (node, args) => executeVisitor(node, new UsesStaticMethodOverload()),
-};

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

@@ -1,8 +0,0 @@
-import { EquationRuntime, PrimitiveValue } from "@yukigo/ast";
-import { EnvStack } from "../index.js";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class FunctionRuntime {
-    static apply(funcName: string, equations: EquationRuntime[], args: PrimitiveValue[], currentEnv: EnvStack, evaluatorFactory: (env: EnvStack) => ExpressionEvaluator): PrimitiveValue;
-    private static patternsMatch;
-    private static evaluateSequence;
-}

package/dist/interpreter/components/FunctionRuntime.js

@@ -1,52 +0,0 @@
-import { UnguardedBody, Return, } from "@yukigo/ast";
-import { PatternMatcher } from "./PatternMatcher.js";
-import { InterpreterError } from "../errors.js";
-class NonExhaustivePatterns extends InterpreterError {
-    constructor(funcName) {
-        super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
-    }
-}
-export class FunctionRuntime {
-    static apply(funcName, equations, args, currentEnv, evaluatorFactory) {
-        for (const eq of equations) {
-            if (eq.patterns.length !== args.length)
-                continue;
-            const bindings = [];
-            if (!FunctionRuntime.patternsMatch(eq, args, bindings))
-                continue;
-            const localEnv = new Map(bindings);
-            const newStack = [localEnv, ...currentEnv];
-            const scopeEvaluator = evaluatorFactory(newStack);
-            // UnguardedBody
-            if (eq.body instanceof UnguardedBody)
-                return this.evaluateSequence(eq.body.sequence, scopeEvaluator);
-            // GuardedBody
-            for (const guard of eq.body) {
-                const cond = scopeEvaluator.evaluate(guard.condition);
-                if (cond === true)
-                    return scopeEvaluator.evaluate(guard.body);
-            }
-        }
-        throw new NonExhaustivePatterns(funcName);
-    }
-    static patternsMatch(eq, args, bindings) {
-        for (let i = 0; i < args.length; i++) {
-            const matcher = new PatternMatcher(args[i], bindings);
-            if (!eq.patterns[i].accept(matcher))
-                return false;
-        }
-        return true;
-    }
-    static evaluateSequence(seq, evaluator) {
-        let result = undefined;
-        for (const stmt of seq.statements) {
-            if (stmt instanceof Return) {
-                return evaluator.evaluate(stmt.body);
-            }
-            else {
-                result = evaluator.evaluate(stmt);
-            }
-        }
-        return result;
-    }
-}

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

@@ -1,7 +0,0 @@
-import { PrimitiveValue, RangeExpression, ConsExpression } from "@yukigo/ast";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class LazyRuntime {
-    static realizeList(val: PrimitiveValue): PrimitiveValue[];
-    static evaluateRange(node: RangeExpression, evaluator: ExpressionEvaluator, config: any): PrimitiveValue;
-    static evaluateCons(node: ConsExpression, evaluator: ExpressionEvaluator, lazy: boolean): PrimitiveValue;
-}

package/dist/interpreter/components/LazyRuntime.js

@@ -1,75 +0,0 @@
-import { isLazyList, } from "@yukigo/ast";
-import { createStream } from "../utils.js";
-export class LazyRuntime {
-    static realizeList(val) {
-        if (Array.isArray(val))
-            return val;
-        if (isLazyList(val)) {
-            const result = [];
-            const iter = val.generator();
-            let next = iter.next();
-            while (!next.done) {
-                if (next.value === undefined)
-                    throw new Error("LazyList yielded undefined");
-                result.push(next.value);
-                next = iter.next();
-            }
-            return result;
-        }
-        throw new Error(`Expected List or LazyList, got ${typeof val}`);
-    }
-    static evaluateRange(node, evaluator, config) {
-        const startVal = evaluator.evaluate(node.start);
-        if (typeof startVal !== "number")
-            throw new Error("Range start must be a number");
-        const hasEnd = node.end != null;
-        let step = 1;
-        if (node.step) {
-            const secondVal = evaluator.evaluate(node.step);
-            if (typeof secondVal !== "number")
-                throw new Error("Range step must be a number");
-            step = secondVal - startVal;
-            if (step === 0)
-                throw new Error("Range step cannot be zero");
-        }
-        if (!hasEnd) {
-            return createStream(function* () {
-                let current = startVal;
-                while (true) {
-                    yield current;
-                    current += step;
-                }
-            });
-        }
-        const endVal = evaluator.evaluate(node.end);
-        if (typeof endVal !== "number")
-            throw new Error("Range end must be a number");
-        const result = [];
-        let current = startVal;
-        const cond = step > 0 ? () => current <= endVal : () => current >= endVal;
-        while (cond()) {
-            result.push(current);
-            current += step;
-        }
-        return result;
-    }
-    static evaluateCons(node, evaluator, lazy) {
-        const head = evaluator.evaluate(node.head);
-        if (lazy) {
-            const tail = evaluator.evaluate(node.tail);
-            if (Array.isArray(tail))
-                return [head, ...tail];
-            if (isLazyList(tail))
-                return createStream(function* () {
-                    yield head;
-                    yield* tail.generator();
-                });
-            throw new Error(`Invalid tail type for Cons: ${typeof tail}`);
-        }
-        // Eager behavior
-        const tail = evaluator.evaluate(node.tail);
-        if (isLazyList(tail) || !Array.isArray(tail))
-            throw new Error("Expected Array in eager Cons");
-        return [head, ...tail];
-    }
-}

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

@@ -1,21 +0,0 @@
-import { Exist, Findall, Goal, PrimitiveValue, Query } from "@yukigo/ast";
-import { EnvStack, InterpreterConfig } from "../index.js";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class LogicEngine {
-    private env;
-    private config;
-    private evaluator;
-    constructor(env: EnvStack, config: InterpreterConfig, evaluator: ExpressionEvaluator);
-    solveQuery(node: Query): PrimitiveValue;
-    solveGoal(node: Goal): PrimitiveValue;
-    solveFindall(node: Findall): PrimitiveValue;
-    solveExist(node: Exist): PrimitiveValue;
-    private solveConjunction;
-    private expressionToPattern;
-    private primitiveToPattern;
-    private instantiateExpressionAsPattern;
-    private substitutePattern;
-    private instantiateTemplate;
-    private handleOutputMode;
-    private formatLogicResult;
-}