yukigo 0.2.2 → 0.3.1

package/dist/interpreter/entities.d.ts

@@ -1,105 +0,0 @@
-import { Fact, Rule, Pattern, GuardedBody, UnguardedBody } from "yukigo-ast";
-export type SuccessLogicResult = {
-    success: true;
-    solutions: Map<string, PrimitiveValue>;
-};
-export type FailedLogicResult = {
-    success: false;
-};
-export type LogicResult = SuccessLogicResult | FailedLogicResult;
-export type PrimitiveValue = number | boolean | string | RuntimeFunction | RuntimePredicate | LogicResult | LazyList | null | void | PrimitiveValue[] | RuntimeObject | RuntimeClass | undefined;
-export declare function isLogicResult(value: PrimitiveValue): value is LogicResult;
-export type PrimitiveThunk = () => PrimitiveValue;
-export type Environment = Map<string, PrimitiveValue>;
-export type EnvStack = {
-    head: Environment;
-    tail: EnvStack | null;
-};
-type RuntimePredicateKind = "Fact" | "Rule" | "Predicate";
-type PredicateEquation = Fact | Rule;
-export interface IRuntimePredicate {
-    kind: RuntimePredicateKind;
-    identifier: string;
-    equations: PredicateEquation[];
-}
-export declare class RuntimePredicate implements IRuntimePredicate {
-    kind: RuntimePredicateKind;
-    identifier: string;
-    equations: PredicateEquation[];
-    constructor(kind: RuntimePredicateKind, identifier: string, equations: PredicateEquation[]);
-    pushEquation<T extends Fact | Rule>(eq: T): void;
-}
-export declare const isRuntimePredicate: (prim: PrimitiveValue) => prim is RuntimePredicate;
-type Body = GuardedBody[] | UnguardedBody;
-export interface IRuntimeEquation {
-    patterns: Pattern[];
-    body: Body;
-}
-export declare class RuntimeEquation implements IRuntimeEquation {
-    patterns: Pattern[];
-    body: Body;
-    constructor(patterns: Pattern[], body: Body);
-}
-type PendingArg = PrimitiveValue | PrimitiveThunk;
-/**
- * Runtime Function used in the Interpreter
- */
-export interface IRuntimeFunction {
-    arity: number;
-    identifier: string;
-    equations: RuntimeEquation[];
-    pendingArgs: PendingArg[];
-    closure?: EnvStack;
-}
-export declare class RuntimeFunction implements IRuntimeFunction {
-    arity: number;
-    identifier: string;
-    equations: RuntimeEquation[];
-    pendingArgs: PendingArg[];
-    closure?: EnvStack;
-    constructor(arity: number, identifier: string, equations: RuntimeEquation[], pendingArgs: PendingArg[], closure?: EnvStack);
-    setPendingArgs(args: PendingArg[]): void;
-}
-export declare function isRuntimeFunction(val: PrimitiveValue): val is RuntimeFunction;
-type Fields = Map<string, PrimitiveValue>;
-type Methods = Map<string, RuntimeFunction>;
-export interface IRuntimeClass {
-    identifier: string;
-    fields: Fields;
-    methods: Methods;
-    mixins: string[];
-    superclass?: string;
-}
-export declare class RuntimeClass implements IRuntimeClass {
-    identifier: string;
-    fields: Fields;
-    methods: Methods;
-    mixins: string[];
-    superclass?: string;
-    constructor(identifier: string, fields: Fields, methods: Methods, mixins: string[], superclass?: string);
-}
-export declare function isRuntimeClass(val: PrimitiveValue): val is RuntimeClass;
-export interface IRuntimeObject {
-    identifier: string;
-    className: string;
-    fields: Map<string, PrimitiveValue>;
-    methods: Map<string, RuntimeFunction>;
-}
-export declare class RuntimeObject implements IRuntimeObject {
-    identifier: string;
-    className: string;
-    fields: Fields;
-    methods: Methods;
-    constructor(identifier: string, className: string, fields: Fields, methods: Methods);
-}
-export declare function isRuntimeObject(val: PrimitiveValue): val is RuntimeObject;
-export type LazyGenerator = () => Generator<PrimitiveValue, void, unknown>;
-export interface ILazyList {
-    readonly generator: LazyGenerator;
-}
-export declare class LazyList implements ILazyList {
-    readonly generator: LazyGenerator;
-    constructor(generator: LazyGenerator);
-}
-export declare function isLazyList(prim: unknown): prim is LazyList;
-export {};

package/dist/interpreter/entities.js

@@ -1,96 +0,0 @@
-export function isLogicResult(value) {
-    return (value &&
-        typeof value === "object" &&
-        "success" in value &&
-        typeof value.success === "boolean" &&
-        "solutions" in value &&
-        value.solutions instanceof Map);
-}
-export class RuntimePredicate {
-    kind;
-    identifier;
-    equations;
-    constructor(kind, identifier, equations) {
-        this.kind = kind;
-        this.identifier = identifier;
-        this.equations = equations;
-    }
-    pushEquation(eq) {
-        this.equations.push(eq);
-    }
-}
-// TODO: Replace with correct polymorphism
-export const isRuntimePredicate = (prim) => {
-    return prim instanceof RuntimePredicate;
-};
-export class RuntimeEquation {
-    patterns;
-    body;
-    constructor(patterns, body) {
-        this.patterns = patterns;
-        this.body = body;
-    }
-}
-export class RuntimeFunction {
-    arity;
-    identifier;
-    equations;
-    pendingArgs;
-    closure;
-    constructor(arity, identifier, equations, pendingArgs, closure) {
-        this.arity = arity;
-        this.identifier = identifier;
-        this.equations = equations;
-        this.pendingArgs = pendingArgs;
-        this.closure = closure;
-    }
-    setPendingArgs(args) {
-        this.pendingArgs = args;
-    }
-}
-// TODO: Replace with correct polymorphism
-export function isRuntimeFunction(val) {
-    return val instanceof RuntimeFunction;
-}
-export class RuntimeClass {
-    identifier;
-    fields;
-    methods;
-    mixins;
-    superclass;
-    constructor(identifier, fields, methods, mixins, superclass) {
-        this.identifier = identifier;
-        this.fields = fields;
-        this.methods = methods;
-        this.mixins = mixins;
-        this.superclass = superclass;
-    }
-}
-// TODO: prev as before
-export function isRuntimeClass(val) {
-    return val instanceof RuntimeClass;
-}
-export class RuntimeObject {
-    identifier;
-    className;
-    fields;
-    methods;
-    constructor(identifier, className, fields, methods) {
-        this.identifier = identifier;
-        this.className = className;
-        this.fields = fields;
-        this.methods = methods;
-    }
-}
-export function isRuntimeObject(val) {
-    return val instanceof RuntimeObject;
-}
-export class LazyList {
-    generator;
-    constructor(generator) {
-        this.generator = generator;
-    }
-}
-export function isLazyList(prim) {
-    return prim instanceof LazyList;
-}

package/dist/interpreter/trampoline.d.ts

@@ -1,17 +0,0 @@
-import { PrimitiveValue } from "yukigo-ast";
-export type CallableThunk<T> = () => Thunk<T>;
-export type Thunk<T> = T | CallableThunk<T>;
-export type Continuation<T, R = any> = (value: T) => Thunk<R>;
-export declare const idContinuation: Continuation<PrimitiveValue>;
-export declare function trampoline<T>(thunk: Thunk<T>): T;
-/**
- * A specialized Thunk type for our CPS visitor.
- * This is a function that, when called, takes the continuation for the current node's evaluation
- * and returns the actual Thunk chain for that node.
- * This effectively injects the continuation *after* the `visit` method has returned.
- */
-export type CPSThunk<T, R = any> = (k: Continuation<T, R>) => Thunk<R>;
-export declare function makeCPSThunk<T>(fn: (k: Continuation<T>) => Thunk<T>): CPSThunk<T>;
-export declare function bindCPS<A, B, R>(cpsA: CPSThunk<A, R>, f: (valueA: A) => CPSThunk<B, R>): CPSThunk<B, R>;
-export declare function valueToCPS<T, R>(value: T): CPSThunk<T, R>;
-export declare function thunkToCPS<T>(thunk: Thunk<T>): CPSThunk<T>;

package/dist/interpreter/trampoline.js

@@ -1,38 +0,0 @@
-const isCallableThunk = (thunk) => typeof thunk === "function";
-// The identity continuation: simply returns the value as a resolved Thunk.
-// This is used for the very last step of a computation or when a value is final.
-export const idContinuation = (value) => value;
-// The trampoline function executes a chain of Thunks until a final non-function value is reached.
-export function trampoline(thunk) {
-    let result = thunk;
-    while (isCallableThunk(result))
-        result = result();
-    return result;
-}
-// Helper to create a CPSThunk for visitor methods.
-// Visitor methods will call this, providing a function that knows how to use 'k'.
-export function makeCPSThunk(fn) {
-    return fn;
-}
-// Helper to compose asynchronous/CPS operations.
-// `cpsA` is a CPSThunk that eventually produces a value A.
-// `f` is a function that takes A and returns a CPSThunk that eventually produces B.
-export function bindCPS(cpsA, f) {
-    return (k) => {
-        return () => cpsA((valueA) => {
-            // f(valueA) returns a CPSThunk<B, R>
-            // calling that with 'k' returns Thunk<R>
-            return f(valueA)(k);
-        });
-    };
-}
-// Helper to lift a direct value into a CPSThunk
-export function valueToCPS(value) {
-    return (k) => () => k(value);
-}
-// Helper to lift a regular Thunk into a CPSThunk (if it resolves a simple Thunk)
-export function thunkToCPS(thunk) {
-    return (k) => {
-        return () => k(trampoline(thunk)); // Trampoline the simple thunk and pass its result to k
-    };
-}

package/dist/src/analyzer/GraphBuilder.d.ts

@@ -1,30 +0,0 @@
-import { Application, AST, ASTNode, Call, Class, Fact, Function, Interface, Method, New, Object as YuObject, Procedure, Rule, TraverseVisitor, TypeAlias, TypeSignature, Exist } from "yukigo-ast";
-type DefinitionMap = Map<string, ASTNode[]>;
-type CallsMap = Map<string, string[]>;
-export type SymbolGraph = {
-    defs: DefinitionMap;
-    calls: CallsMap;
-};
-export declare class GraphBuilder extends TraverseVisitor {
-    private defs;
-    private calls;
-    private scope;
-    build(ast: AST): SymbolGraph;
-    private addDefinition;
-    visitFunction(node: Function): void;
-    visitMethod(node: Method): void;
-    visitProcedure(node: Procedure): void;
-    visitRule(node: Rule): void;
-    visitFact(node: Fact): void;
-    visitClass(node: Class): void;
-    visitObject(node: YuObject): void;
-    visitInterface(node: Interface): void;
-    visitTypeAlias(node: TypeAlias): void;
-    visitTypeSignature(node: TypeSignature): void;
-    visitCall(node: Call): void;
-    visitApplication(node: Application): void;
-    visitNew(node: New): void;
-    visitExist(node: Exist): void;
-    fallback(node: ASTNode): void;
-}
-export {};

package/dist/src/analyzer/GraphBuilder.js

@@ -1,100 +0,0 @@
-import { SymbolPrimitive, TraverseVisitor, } from "yukigo-ast";
-export class GraphBuilder extends TraverseVisitor {
-    defs = new Map();
-    calls = new Map();
-    scope = "";
-    build(ast) {
-        ast.forEach((node) => node.accept(this));
-        return { defs: this.defs, calls: this.calls };
-    }
-    addDefinition(name, node) {
-        const existing = this.defs.get(name) || [];
-        this.defs.set(name, [...existing, node]);
-    }
-    visitFunction(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.traverseCollection(node.equations);
-        this.scope = "";
-    }
-    visitMethod(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.traverseCollection(node.equations);
-        this.scope = "";
-    }
-    visitProcedure(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.traverseCollection(node.equations);
-        this.scope = "";
-    }
-    visitRule(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.traverseCollection(node.equations);
-        this.scope = "";
-    }
-    visitFact(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.traverseCollection(node.patterns);
-        this.scope = "";
-    }
-    visitClass(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        node.expression.accept(this);
-        this.scope = "";
-    }
-    visitObject(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        node.expression.accept(this);
-        this.scope = "";
-    }
-    visitInterface(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        node.expression.accept(this);
-        this.scope = "";
-    }
-    visitTypeAlias(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.scope = "";
-    }
-    visitTypeSignature(node) {
-        this.scope = node.identifier.value;
-        this.addDefinition(this.scope, node);
-        this.scope = "";
-    }
-    visitCall(node) {
-        if (!this.scope)
-            return;
-        const arr = this.calls.get(this.scope) || [];
-        this.calls.set(this.scope, [node.callee.value, ...arr]);
-    }
-    visitApplication(node) {
-        if (!this.scope)
-            return;
-        const arr = this.calls.get(this.scope) || [];
-        if (node.functionExpr instanceof SymbolPrimitive)
-            this.calls.set(this.scope, [node.functionExpr.value, ...arr]);
-        else
-            node.functionExpr.accept(this);
-    }
-    visitNew(node) {
-        if (!this.scope)
-            return;
-        const arr = this.calls.get(this.scope) || [];
-        this.calls.set(this.scope, [node.identifier.value, ...arr]);
-    }
-    visitExist(node) {
-        if (!this.scope)
-            return;
-        const arr = this.calls.get(this.scope) || [];
-        this.calls.set(this.scope, [node.identifier.value, ...arr]);
-    }
-    fallback(node) { }
-}

package/dist/src/analyzer/index.d.ts

@@ -1,59 +0,0 @@
-import { AST } from "yukigo-ast";
-import { InspectionMap, VisitorConstructor } from "./utils.js";
-export type AnalysisResult = {
-    rule: InspectionRule;
-    passed: boolean;
-    actual: boolean;
-    error?: string;
-};
-export type InspectionRule = {
-    inspection: string;
-    binding?: string;
-    args?: string[];
-    expected: boolean;
-};
-export declare const DefaultInspectionSet: InspectionMap;
-export declare const DefaultSmellsSet: InspectionMap;
-/**
- * The Analyzer class.
- * @remarks
- * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
- */
-export declare class Analyzer {
-    /**
-     * The set of inspections that are available for the Analyzer.
-     * You can load your set of inspections or leave the default one.
-     * @defaultValue a default set of inspections for each supported paradigm
-     */
-    private inspectionConstructors;
-    private smellsConstructors;
-    constructor(inspectionSet?: InspectionMap, smellsSet?: InspectionMap);
-    /**
-     * Registers a new custom inspection handler after Analyzer was instantiated.
-     * @param name The name of the inspection (e.g., "HasArithmetic").
-     * @param visitorConstructor The constructor for the TraverseVisitor class.
-     */
-    registerInspection(name: string, visitorConstructor: VisitorConstructor): void;
-    /**
-     * Runs a list of inspection rules against the AST.
-     * @param ast The parsed AST.
-     * @param rules The array of inspection rules to run.
-     * @returns An array of analysis results.
-     * @example
-     * const rules: InspectionRule[] = [
-     *  {
-     *    inspection: "HasBinding",
-     *    args: { name: "minimoEntre" },
-     *    expected: false,
-     *  },
-     *  {
-     *    inspection: "HasBinding",
-     *    args: { name: "squareList" },
-     *    expected: true,
-     *  }
-     * ]
-     * const analyzer = new ASTAnalyzer(ast);
-     * const analysisResults = analyzer.analyze(expectations);
-     */
-    analyze(ast: AST, rules: InspectionRule[]): AnalysisResult[];
-}

package/dist/src/analyzer/index.js

@@ -1,152 +0,0 @@
-import { StopTraversalException } from "yukigo-ast";
-import { genericInspections } from "./inspections/generic/generic.js";
-import { functionalInspections } from "./inspections/functional/functional.js";
-import { logicInspections } from "./inspections/logic/logic.js";
-import { objectInspections } from "./inspections/object/object.js";
-import { imperativeInspections } from "./inspections/imperative/imperative.js";
-import { functionalSmells } from "./inspections/functional/smells.js";
-import { logicSmells } from "./inspections/logic/smells.js";
-import { objectSmells } from "./inspections/object/smells.js";
-import { imperativeSmells } from "./inspections/imperative/smells.js";
-import { genericSmells } from "./inspections/generic/smells.js";
-import { GraphBuilder } from "./GraphBuilder.js";
-export const DefaultInspectionSet = {
-    ...genericInspections,
-    ...functionalInspections,
-    ...logicInspections,
-    ...objectInspections,
-    ...imperativeInspections,
-};
-export const DefaultSmellsSet = {
-    ...genericSmells,
-    ...functionalSmells,
-    ...logicSmells,
-    ...objectSmells,
-    ...imperativeSmells,
-};
-/**
- * The Analyzer class.
- * @remarks
- * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
- */
-export class Analyzer {
-    /**
-     * The set of inspections that are available for the Analyzer.
-     * You can load your set of inspections or leave the default one.
-     * @defaultValue a default set of inspections for each supported paradigm
-     */
-    inspectionConstructors = {};
-    smellsConstructors = {};
-    constructor(inspectionSet, smellsSet) {
-        this.inspectionConstructors = inspectionSet ?? DefaultInspectionSet;
-        this.smellsConstructors = smellsSet ?? DefaultSmellsSet;
-    }
-    /**
-     * Registers a new custom inspection handler after Analyzer was instantiated.
-     * @param name The name of the inspection (e.g., "HasArithmetic").
-     * @param visitorConstructor The constructor for the TraverseVisitor class.
-     */
-    registerInspection(name, visitorConstructor) {
-        this.inspectionConstructors[name] = visitorConstructor;
-    }
-    /**
-     * Runs a list of inspection rules against the AST.
-     * @param ast The parsed AST.
-     * @param rules The array of inspection rules to run.
-     * @returns An array of analysis results.
-     * @example
-     * const rules: InspectionRule[] = [
-     *  {
-     *    inspection: "HasBinding",
-     *    args: { name: "minimoEntre" },
-     *    expected: false,
-     *  },
-     *  {
-     *    inspection: "HasBinding",
-     *    args: { name: "squareList" },
-     *    expected: true,
-     *  }
-     * ]
-     * const analyzer = new ASTAnalyzer(ast);
-     * const analysisResults = analyzer.analyze(expectations);
-     */
-    analyze(ast, rules) {
-        const ruleResults = new Map();
-        const graphBuilder = new GraphBuilder();
-        const { defs, calls } = graphBuilder.build(ast);
-        for (const rule of rules) {
-            let inspectionName = rule.inspection;
-            let isTransitive = true;
-            if (inspectionName.startsWith("Intransitive:")) {
-                isTransitive = false;
-                inspectionName = inspectionName.replace("Intransitive:", "");
-            }
-            const InspectionClass = this.inspectionConstructors[inspectionName];
-            if (!InspectionClass) {
-                ruleResults.set(rule, {
-                    rule,
-                    passed: false,
-                    actual: false,
-                    error: "Unknown inspection: " + inspectionName,
-                });
-                continue;
-            }
-            if (InspectionClass.IS_INTRANSITIVE)
-                isTransitive = false;
-            let targets = [];
-            // Case 1: Global Inspection (No binding or wildcard)
-            if (!rule.binding || rule.binding === "*") {
-                targets = ast.map((n) => ({ node: n, binding: undefined }));
-            }
-            // Case 2: Directed Inspection (Specific binding)
-            else {
-                const workList = [rule.binding];
-                const visited = new Set();
-                while (workList.length > 0) {
-                    const currentBinding = workList.shift();
-                    if (!currentBinding || visited.has(currentBinding))
-                        continue;
-                    visited.add(currentBinding);
-                    const node = defs.get(currentBinding);
-                    if (node)
-                        node.forEach((n) => targets.push({ node: n, binding: currentBinding }));
-                    if (isTransitive) {
-                        const deps = calls.get(currentBinding) || [];
-                        workList.push(...deps);
-                    }
-                }
-            }
-            let actual = false;
-            let error = undefined;
-            // Execution Loop
-            const isGlobalVisitor = !rule.binding || rule.binding === "*";
-            const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
-            const args = rule.args ?? [];
-            const visitor = new InspectionClass(...args, normalizedBinding);
-            for (const { node, binding } of targets) {
-                try {
-                    if (!isGlobalVisitor && visitor.setBinding && binding) {
-                        visitor.setBinding(binding);
-                    }
-                    node.accept(visitor);
-                }
-                catch (e) {
-                    if (e instanceof StopTraversalException) {
-                        actual = true;
-                        break; // Short-circuit: Rule passed
-                    }
-                    else {
-                        error = e.message;
-                    }
-                }
-            }
-            ruleResults.set(rule, {
-                rule,
-                passed: actual === rule.expected,
-                actual,
-                error,
-            });
-        }
-        return [...ruleResults.values()];
-    }
-}

package/dist/src/analyzer/inspections/functional/functional.d.ts

@@ -1,44 +0,0 @@
-import * as Yu from "yukigo-ast";
-import { VisitorConstructor, ScopedVisitor } from "../../utils.js";
-export declare class UsesComposition extends ScopedVisitor {
-    constructor(scope?: string);
-    visitCompositionExpression(node: Yu.CompositionExpression): void;
-}
-export declare class UsesAnonymousVariable extends ScopedVisitor {
-    constructor(scope?: string);
-    visitWildcardPattern(node: Yu.WildcardPattern): void;
-}
-export declare class UsesComprehension extends ScopedVisitor {
-    constructor(scope?: string);
-    visitListComprehension(node: Yu.ListComprehension): void;
-}
-export declare class UsesGuards extends ScopedVisitor {
-    constructor(scope?: string);
-    visitGuardedBody(node: Yu.GuardedBody): void;
-}
-export declare class UsesOtherwise extends ScopedVisitor {
-    constructor(scope?: string);
-    visitOtherwise(node: Yu.Otherwise): void;
-}
-export declare class UsesLambda extends ScopedVisitor {
-    constructor(scope?: string);
-    visitLambda(node: Yu.Lambda): void;
-}
-export declare class UsesYield extends ScopedVisitor {
-    constructor(scope?: string);
-    visitYield(node: Yu.Yield): void;
-}
-export declare class UsesPatternMatching extends ScopedVisitor {
-    constructor(scope?: string);
-    visitConsPattern(node: Yu.ConsPattern): void;
-    visitAsPattern(node: Yu.AsPattern): void;
-    visitListPattern(node: Yu.ListPattern): void;
-    visitTuplePattern(node: Yu.TuplePattern): void;
-    visitLiteralPattern(node: Yu.LiteralPattern): void;
-    visitApplicationPattern(node: Yu.ApplicationPattern): void;
-    visitConstructorPattern(node: Yu.ConstructorPattern): void;
-    visitUnionPattern(node: Yu.UnionPattern): void;
-    visitFunctorPattern(node: Yu.FunctorPattern): void;
-    visitWildcardPattern(node: Yu.WildcardPattern): void;
-}
-export declare const functionalInspections: Record<string, VisitorConstructor>;