yukigo 0.2.3 → 0.3.2

package/dist/interpreter/primitives/entities/RuntimePredicate.js

@@ -0,0 +1,59 @@
+import { Fact } from "yukigo-ast";
+import { InterpreterError } from "../../errors.js";
+import { YuValue } from "../YuValue.js";
+import { boolean, error, raise } from "../../utils.js";
+export class RuntimePredicate extends YuValue {
+    identifier;
+    equations;
+    arity;
+    constructor(identifier, equations) {
+        super();
+        this.identifier = identifier;
+        this.equations = equations;
+        if (equations.length === 0) {
+            throw new InterpreterError("RuntimePredicate", `Predicate "${identifier}" must have at least one clause.`);
+        }
+        this.arity = this.getArityFromClause(equations[0]);
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("RuntimePredicate.compare", "Predicates are not comparable"));
+    }
+    apply(visitor) {
+        return this.equations.map((clause) => clause.accept(visitor));
+    }
+    addClause(clause) {
+        const clauseArity = this.getArityFromClause(clause);
+        if (!this.validateClause(clause)) {
+            throw new InterpreterError("RuntimePredicate", `Arity mismatch for "${this.identifier}": expected ${this.arity}, got ${clauseArity}.`);
+        }
+        this.equations.push(clause);
+    }
+    validateClause(clause) {
+        const clauseArity = this.getArityFromClause(clause);
+        return this.validateArity(clauseArity);
+    }
+    validateArity(args) {
+        return this.arity === args;
+    }
+    getArityFromClause(clause) {
+        if (clause.is(Fact))
+            return clause.patterns.length;
+        const patterns = clause.equations.length > 0 ? clause.equations[0].patterns : [];
+        return patterns.length;
+    }
+    toJSON() {
+        return {
+            identifier: this.identifier,
+            arity: this.arity,
+        };
+    }
+    toString() {
+        return `[Predicate: ${this.identifier}/${this.arity}]`;
+    }
+}
+export const isRuntimePredicate = (prim) => {
+    return prim instanceof RuntimePredicate;
+};

package/dist/interpreter/primitives/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./YuValue.js";
+export * from "./capabilities.js";
+export { YuBoolean } from "./scalars/YuBoolean.js";
+export { YuNil } from "./scalars/YuNil.js";
+export { YuNumber } from "./scalars/YuNumber.js";
+export { YuArray } from "./sequences/YuArray.js";
+export { YuChar } from "./scalars/YuChar.js";
+export { YuString } from "./sequences/YuString.js";
+export * from "./entities/LazyList.js";
+export * from "./entities/LogicResult.js";
+export * from "./entities/RuntimeClass.js";
+export * from "./entities/RuntimeFunction.js";
+export * from "./entities/RuntimeObject.js";
+export * from "./entities/RuntimePredicate.js";

package/dist/interpreter/primitives/index.js

@@ -0,0 +1,14 @@
+export * from "./YuValue.js";
+export * from "./capabilities.js";
+export { YuBoolean } from "./scalars/YuBoolean.js";
+export { YuNil } from "./scalars/YuNil.js";
+export { YuNumber } from "./scalars/YuNumber.js";
+export { YuArray } from "./sequences/YuArray.js";
+export { YuChar } from "./scalars/YuChar.js";
+export { YuString } from "./sequences/YuString.js";
+export * from "./entities/LazyList.js";
+export * from "./entities/LogicResult.js";
+export * from "./entities/RuntimeClass.js";
+export * from "./entities/RuntimeFunction.js";
+export * from "./entities/RuntimeObject.js";
+export * from "./entities/RuntimePredicate.js";

package/dist/interpreter/primitives/scalars/YuBoolean.d.ts

@@ -0,0 +1,24 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { Comparable, Logic, YuComparable, YuLogic } from "../capabilities.js";
+import { YuValue } from "../YuValue.js";
+export declare class YuBoolean extends YuValue implements Logic, Comparable {
+    readonly value: boolean;
+    constructor(value: boolean);
+    get asLogic(): YuLogic;
+    get asComparable(): YuComparable;
+    not(): ExecutionCommand;
+    equals(other: YuValue): ExecutionCommand;
+    equalsWithNumber(): ExecutionCommand;
+    equalsWithBoolean(left: YuBoolean): ExecutionCommand;
+    equalsWithString(): ExecutionCommand;
+    equalsWithArray(): ExecutionCommand;
+    equalsWithNil(): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(): ExecutionCommand;
+    compareWithBoolean(left: YuBoolean): ExecutionCommand;
+    compareWithString(): ExecutionCommand;
+    compareWithArray(): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    toString(): string;
+    toJSON(): boolean;
+}

package/dist/interpreter/primitives/scalars/YuBoolean.js

@@ -0,0 +1,69 @@
+import { StepCommand, } from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import { YuValue } from "../YuValue.js";
+import { YuNumber } from "./YuNumber.js";
+export class YuBoolean extends YuValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get asLogic() {
+        return this;
+    }
+    get asComparable() {
+        return this;
+    }
+    not() {
+        return boolean(!this.value);
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithBoolean(this);
+    }
+    equalsWithNumber() {
+        return boolean(false);
+    }
+    equalsWithBoolean(left) {
+        return boolean(left.value === this.value);
+    }
+    equalsWithString() {
+        return boolean(false);
+    }
+    equalsWithArray() {
+        return boolean(false);
+    }
+    equalsWithNil() {
+        return boolean(false);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithBoolean(this);
+    }
+    compareWithNumber() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithBoolean(left) {
+        return new StepCommand(new YuNumber((left.value ? 1 : 0) - (this.value ? 1 : 0)));
+    }
+    compareWithString() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithArray() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithNil() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    toString() {
+        return this.value.toString();
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/interpreter/primitives/scalars/YuChar.d.ts

@@ -0,0 +1,28 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { Comparable, Summable, YuComparable, YuSummable } from "../capabilities.js";
+import { YuString } from "../sequences/YuString.js";
+import { YuValue } from "../YuValue.js";
+import { YuNumber } from "./YuNumber.js";
+export declare class YuChar extends YuValue implements Comparable, Summable {
+    readonly value: string;
+    constructor(value: string);
+    get asSummable(): YuSummable;
+    get asComparable(): YuComparable;
+    equals(other: YuValue): ExecutionCommand;
+    equalsWithNumber(): ExecutionCommand;
+    equalsWithBoolean(): ExecutionCommand;
+    equalsWithString(left: YuString): ExecutionCommand;
+    equalsWithArray(): ExecutionCommand;
+    equalsWithNil(): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(): ExecutionCommand;
+    compareWithBoolean(): ExecutionCommand;
+    compareWithString(left: YuString): ExecutionCommand;
+    compareWithArray(): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    plus(other: YuValue): ExecutionCommand;
+    plusWithNumber(left: YuNumber): ExecutionCommand;
+    plusWithString(left: YuString): ExecutionCommand;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/interpreter/primitives/scalars/YuChar.js

@@ -0,0 +1,78 @@
+import { StepCommand, } from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import { YuString } from "../sequences/YuString.js";
+import { YuValue } from "../YuValue.js";
+import { YuNumber } from "./YuNumber.js";
+export class YuChar extends YuValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+        if (value.length !== 1)
+            throw new Error("YuChar must be a single character");
+    }
+    get asSummable() {
+        return this;
+    }
+    get asComparable() {
+        return this;
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithString(this);
+    }
+    equalsWithNumber() {
+        return boolean(false);
+    }
+    equalsWithBoolean() {
+        return boolean(false);
+    }
+    equalsWithString(left) {
+        return boolean(left.toJSON() === this.value);
+    }
+    equalsWithArray() {
+        return boolean(false);
+    }
+    equalsWithNil() {
+        return boolean(false);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithString(new YuString(this.value));
+    }
+    compareWithNumber() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithBoolean() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithString(left) {
+        return new StepCommand(new YuNumber(left.toJSON().localeCompare(this.value)));
+    }
+    compareWithArray() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithNil() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    plus(other) {
+        return new StepCommand(new YuString(this.value + other.toString()));
+    }
+    plusWithNumber(left) {
+        return new StepCommand(new YuString(left.toJSON().toString() + this.value));
+    }
+    plusWithString(left) {
+        return new StepCommand(new YuString(left.toJSON() + this.value));
+    }
+    toString() {
+        return this.value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/interpreter/primitives/scalars/YuNil.d.ts

@@ -0,0 +1,25 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { Comparable, YuComparable } from "../capabilities.js";
+import { YuValue } from "../YuValue.js";
+export declare class YuNil extends YuValue implements Comparable {
+    private static instance;
+    private constructor();
+    static getInstance(): YuNil;
+    get isNil(): boolean;
+    get asComparable(): YuComparable;
+    equals(other: YuValue): ExecutionCommand;
+    equalsWithNumber(): ExecutionCommand;
+    equalsWithBoolean(): ExecutionCommand;
+    equalsWithString(): ExecutionCommand;
+    equalsWithArray(): ExecutionCommand;
+    equalsWithNil(left: YuNil): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(): ExecutionCommand;
+    compareWithBoolean(): ExecutionCommand;
+    compareWithString(): ExecutionCommand;
+    compareWithArray(): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    private unsupportedCompare;
+    toString(): string;
+    toJSON(): null;
+}

package/dist/interpreter/primitives/scalars/YuNil.js

@@ -0,0 +1,73 @@
+import { StepCommand, } from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import { YuValue } from "../YuValue.js";
+import { YuNumber } from "./YuNumber.js";
+export class YuNil extends YuValue {
+    static instance;
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!YuNil.instance)
+            YuNil.instance = new YuNil();
+        return YuNil.instance;
+    }
+    get isNil() {
+        return true;
+    }
+    get asComparable() {
+        return this;
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithNil(this);
+    }
+    equalsWithNumber() {
+        return boolean(false);
+    }
+    equalsWithBoolean() {
+        return boolean(false);
+    }
+    equalsWithString() {
+        return boolean(false);
+    }
+    equalsWithArray() {
+        return boolean(false);
+    }
+    equalsWithNil(left) {
+        return boolean(true);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithNil(this);
+    }
+    compareWithNumber() {
+        return this.unsupportedCompare();
+    }
+    compareWithBoolean() {
+        return this.unsupportedCompare();
+    }
+    compareWithString() {
+        return this.unsupportedCompare();
+    }
+    compareWithArray() {
+        return this.unsupportedCompare();
+    }
+    compareWithNil() {
+        return new StepCommand(new YuNumber(0));
+    }
+    unsupportedCompare() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    toString() {
+        return "nil";
+    }
+    toJSON() {
+        return null;
+    }
+}

package/dist/interpreter/primitives/scalars/YuNumber.d.ts

@@ -0,0 +1,49 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { Comparable, Numeric, Summable, YuComparable, YuNumeric, YuSummable } from "../capabilities.js";
+import { YuString } from "../sequences/YuString.js";
+import { YuValue } from "../YuValue.js";
+export declare class YuNumber extends YuValue implements Summable, Numeric, Comparable {
+    readonly value: number;
+    constructor(value: number);
+    get asSummable(): YuSummable;
+    get asNumeric(): YuNumeric;
+    get asComparable(): YuComparable;
+    round(): ExecutionCommand;
+    abs(): ExecutionCommand;
+    ceil(): ExecutionCommand;
+    floor(): ExecutionCommand;
+    negation(): ExecutionCommand;
+    sqrt(): ExecutionCommand;
+    plus(other: YuValue): ExecutionCommand;
+    plusWithNumber(left: YuNumber): ExecutionCommand;
+    plusWithString(left: YuString): ExecutionCommand;
+    realize(): ExecutionCommand;
+    minus(other: YuValue): ExecutionCommand;
+    minusWithNumber(left: YuNumber): ExecutionCommand;
+    multiply(other: YuValue): ExecutionCommand;
+    multiplyWithNumber(left: YuNumber): ExecutionCommand;
+    divide(other: YuValue): ExecutionCommand;
+    divideWithNumber(left: YuNumber): ExecutionCommand;
+    modulo(other: YuValue): ExecutionCommand;
+    moduloWithNumber(left: YuNumber): ExecutionCommand;
+    power(other: YuValue): ExecutionCommand;
+    powerWithNumber(left: YuNumber): ExecutionCommand;
+    min(other: YuValue): ExecutionCommand;
+    minWithNumber(left: YuNumber): ExecutionCommand;
+    max(other: YuValue): ExecutionCommand;
+    maxWithNumber(left: YuNumber): ExecutionCommand;
+    equals(other: YuValue): ExecutionCommand;
+    equalsWithNumber(left: YuNumber): ExecutionCommand;
+    equalsWithBoolean(): ExecutionCommand;
+    equalsWithString(left: YuString): ExecutionCommand;
+    equalsWithArray(): ExecutionCommand;
+    equalsWithNil(): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(left: YuNumber): ExecutionCommand;
+    compareWithBoolean(): ExecutionCommand;
+    compareWithString(left: YuString): ExecutionCommand;
+    compareWithArray(): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    toString(): string;
+    toJSON(): number;
+}

package/dist/interpreter/primitives/scalars/YuNumber.js

@@ -0,0 +1,165 @@
+import { StepCommand, } from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, number, raise } from "../../utils.js";
+import { YuString } from "../sequences/YuString.js";
+import { YuValue } from "../YuValue.js";
+export class YuNumber extends YuValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get asSummable() {
+        return this;
+    }
+    get asNumeric() {
+        return this;
+    }
+    get asComparable() {
+        return this;
+    }
+    round() {
+        return number(Math.round(this.value));
+    }
+    abs() {
+        return number(Math.abs(this.value));
+    }
+    ceil() {
+        return number(Math.ceil(this.value));
+    }
+    floor() {
+        return number(Math.floor(this.value));
+    }
+    negation() {
+        return number(this.value * -1);
+    }
+    sqrt() {
+        return number(Math.sqrt(this.value));
+    }
+    plus(other) {
+        const s = other.asSummable;
+        if (!s)
+            return raise(new UnsupportedOperation(other, "plus"));
+        return s.plusWithNumber(this);
+    }
+    plusWithNumber(left) {
+        return number(left.value + this.value);
+    }
+    plusWithString(left) {
+        return new StepCommand(new YuString(left.toJSON() + this.value.toString()));
+    }
+    realize() {
+        return new StepCommand(this);
+    }
+    minus(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "minus"));
+        return n.minusWithNumber(this);
+    }
+    minusWithNumber(left) {
+        return number(left.value - this.value);
+    }
+    multiply(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "multiply"));
+        return n.multiplyWithNumber(this);
+    }
+    multiplyWithNumber(left) {
+        return number(left.value * this.value);
+    }
+    divide(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "divide"));
+        return n.divideWithNumber(this);
+    }
+    divideWithNumber(left) {
+        return number(left.value / this.value);
+    }
+    modulo(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "modulo"));
+        return n.moduloWithNumber(this);
+    }
+    moduloWithNumber(left) {
+        return number(left.value % this.value);
+    }
+    power(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "power"));
+        return n.powerWithNumber(this);
+    }
+    powerWithNumber(left) {
+        return number(left.value ** this.value);
+    }
+    min(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "power"));
+        return n.minWithNumber(this);
+    }
+    minWithNumber(left) {
+        return number(Math.min(left.value, this.value));
+    }
+    max(other) {
+        const n = other.asNumeric;
+        if (!n)
+            return raise(new UnsupportedOperation(other, "power"));
+        return n.maxWithNumber(this);
+    }
+    maxWithNumber(left) {
+        return number(Math.max(left.value, this.value));
+    }
+    equals(other) {
+        const c = other.asComparable;
+        if (!c)
+            return boolean(false);
+        return c.equalsWithNumber(this);
+    }
+    equalsWithNumber(left) {
+        return boolean(left.value === this.value);
+    }
+    equalsWithBoolean() {
+        return boolean(false);
+    }
+    equalsWithString(left) {
+        return boolean(left.toJSON() === this.value.toString());
+    }
+    equalsWithArray() {
+        return boolean(false);
+    }
+    equalsWithNil() {
+        return boolean(false);
+    }
+    compare(other) {
+        const c = other.asComparable;
+        if (!c)
+            return raise(new UnsupportedOperation(other, "compare"));
+        return c.compareWithNumber(this);
+    }
+    compareWithNumber(left) {
+        return number(left.value - this.value);
+    }
+    compareWithBoolean() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithString(left) {
+        return number(Number(left.toJSON()) - this.value);
+    }
+    compareWithArray() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    compareWithNil() {
+        return raise(new UnsupportedOperation(this, "compare"));
+    }
+    toString() {
+        return this.value.toString();
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/interpreter/primitives/sequences/YuArray.d.ts

@@ -0,0 +1,33 @@
+import { YuValue } from "../YuValue.js";
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { Comparable, Sequence, YuComparable, YuSequence } from "../capabilities.js";
+import { YuString } from "../index.js";
+export declare class YuArray extends YuValue implements Sequence, Comparable {
+    readonly items: YuValue[];
+    readonly index: number;
+    constructor(items: YuValue[], index?: number);
+    get asSequence(): YuSequence;
+    get asComparable(): YuComparable;
+    [Symbol.iterator](): Iterator<YuValue>;
+    size(): ExecutionCommand;
+    step(): ExecutionCommand;
+    concat(other: YuValue): ExecutionCommand;
+    concatWithArray(arr: YuArray): ExecutionCommand;
+    concatWithString(str: YuString): ExecutionCommand;
+    at(index: number): YuValue;
+    flat(): YuArray;
+    equals(other: YuValue): ExecutionCommand;
+    equalsWithNumber(): ExecutionCommand;
+    equalsWithBoolean(): ExecutionCommand;
+    equalsWithString(): ExecutionCommand;
+    equalsWithArray(left: YuArray): ExecutionCommand;
+    equalsWithNil(): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    compareWithNumber(): ExecutionCommand;
+    compareWithBoolean(): ExecutionCommand;
+    compareWithString(): ExecutionCommand;
+    compareWithArray(left: YuArray): ExecutionCommand;
+    compareWithNil(): ExecutionCommand;
+    toJSON(keyOrSeen?: string | Set<YuValue>): unknown;
+    toString(seen?: Set<YuValue>): string;
+}