yukigo 0.2.3 → 0.3.2

package/src/interpreter/primitives/scalars/YuNumber.ts

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

package/src/interpreter/primitives/sequences/YuArray.ts

@@ -0,0 +1,178 @@
+import { YuValue } from "../YuValue.js";
+import {
+  BindCommand,
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { YuNil } from "../scalars/YuNil.js";
+import { UnsupportedOperation } from "../../errors.js";
+import {
+  Comparable,
+  Sequence,
+  YuComparable,
+  YuSequence,
+} from "../capabilities.js";
+import { LazyStepResult } from "../entities/LazyList.js";
+import { YuBoolean, YuNumber, YuString } from "../index.js";
+import { boolean, compareResult, number, raise } from "../../utils.js";
+
+export class YuArray extends YuValue implements Sequence, Comparable {
+  constructor(
+    public readonly items: YuValue[],
+    public readonly index: number = 0,
+  ) {
+    super();
+  }
+
+  get asSequence(): YuSequence {
+    return this;
+  }
+  get asComparable(): YuComparable {
+    return this;
+  }
+
+  public *[Symbol.iterator](): Iterator<YuValue> {
+    for (let i = this.index; i < this.items.length; i++) {
+      yield this.items[i];
+    }
+  }
+
+  public size(): ExecutionCommand {
+    return number(this.items.length);
+  }
+
+  public step(): ExecutionCommand {
+    if (this.index >= this.items.length) {
+      return new StepCommand(YuNil.getInstance());
+    }
+    const item = this.items[this.index];
+    const tail = new YuArray(this.items, this.index + 1);
+    return new StepCommand(new LazyStepResult(item, tail));
+  }
+
+  public concat(other: YuValue): ExecutionCommand {
+    const seq = other.asSequence;
+    if (!seq) return raise(new UnsupportedOperation(other, "concat"));
+    return seq.concatWithArray(this);
+  }
+  public concatWithArray(arr: YuArray): ExecutionCommand {
+    return new StepCommand(new YuArray([...arr, ...this]));
+  }
+
+  public concatWithString(str: YuString): ExecutionCommand {
+    return new StepCommand(new YuString(this.toJSON() + str.toJSON()));
+  }
+
+  public at(index: number) {
+    return this.items[this.index + index];
+  }
+
+  public flat() {
+    return new YuArray(
+      [...this].flatMap((item) => {
+        const seq = item.asSequence;
+        return seq instanceof YuArray ? [...seq] : [item];
+      }),
+    );
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return boolean(false);
+    return c.equalsWithArray(this);
+  }
+
+  public equalsWithNumber(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithBoolean(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithString(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithArray(left: YuArray): ExecutionCommand {
+    return new BindCommand(left.size(), (res) => {
+      const leftSize = res.asNumeric?.asComparable;
+      if (!leftSize || !leftSize.equals(new YuNumber(this.items.length)))
+        return boolean(false);
+      const compareNext = (index: number): ExecutionCommand => {
+        if (
+          compareResult(
+            leftSize.compare(new YuNumber(index)),
+            (res) => res >= 0,
+          )
+        ) {
+          return boolean(true);
+        }
+        return new BindCommand(left.at(index).equals(this.at(index)), (res) => {
+          if (!res.toJSON()) return boolean(false);
+          return compareNext(index + 1);
+        });
+      };
+
+      return compareNext(0);
+    });
+  }
+  public equalsWithNil(): ExecutionCommand {
+    return boolean(false);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return raise(new UnsupportedOperation(other, "compare"));
+    return c.compareWithArray(this);
+  }
+
+  public compareWithNumber(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithBoolean(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithString(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithArray(left: YuArray): ExecutionCommand {
+    const a = [...left];
+    const b = [...this];
+    const minLen = Math.min(a.length, b.length);
+
+    const compareNext = (index: number): ExecutionCommand => {
+      if (index >= minLen) {
+        return new StepCommand(new YuNumber(a.length - b.length));
+      }
+      return new BindCommand(a[index].compare(b[index]), (res) => {
+        const cmp = res.toJSON() as number;
+        if (cmp !== 0) {
+          return new StepCommand(res);
+        }
+        return compareNext(index + 1);
+      });
+    };
+
+    return compareNext(0);
+  }
+  public compareWithNil(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+
+  public toJSON(keyOrSeen?: string | Set<YuValue>): unknown {
+    const seen = keyOrSeen instanceof Set ? keyOrSeen : new Set<YuValue>();
+    if (seen.has(this)) return "[Circular]";
+    seen.add(this);
+    const result = this.index === 0
+      ? this.items.map((i) => i.toJSON(seen))
+      : this.items.slice(this.index).map((i) => i.toJSON(seen));
+    seen.delete(this);
+    return result;
+  }
+
+  public toString(seen = new Set<YuValue>()): string {
+    if (seen.has(this)) return "[Circular]";
+    seen.add(this);
+    const result = `[${[...this].map((i) => i.toString(seen)).join(", ")}]`;
+    seen.delete(this);
+    return result;
+  }
+}

package/src/interpreter/primitives/sequences/YuString.ts

@@ -0,0 +1,165 @@
+import { YuValue } from "../YuValue.js";
+import { YuChar } from "../scalars/YuChar.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { YuNil } from "../scalars/YuNil.js";
+import { YuNumber } from "../scalars/YuNumber.js";
+import { YuArray } from "./YuArray.js";
+import { UnsupportedOperation } from "../../errors.js";
+import {
+  Comparable,
+  Sequence,
+  Summable,
+  YuComparable,
+  YuSequence,
+  YuSummable,
+} from "../capabilities.js";
+import { LazyStepResult, YuBoolean } from "../index.js";
+import { boolean, number, raise } from "../../utils.js";
+
+export class YuString
+  extends YuValue
+  implements Sequence, Summable, Comparable
+{
+  constructor(
+    public readonly value: string,
+    public readonly index: number = 0,
+  ) {
+    super();
+  }
+
+  get asSequence(): YuSequence {
+    return this;
+  }
+  get asSummable(): YuSummable {
+    return this;
+  }
+  get asComparable(): YuComparable {
+    return this;
+  }
+
+  public *[Symbol.iterator](): Iterator<YuChar> {
+    for (let i = this.index; i < this.value.length; i++) {
+      yield new YuChar(this.value[i]);
+    }
+  }
+
+  public step(): ExecutionCommand {
+    if (this.index >= this.value.length) {
+      return new StepCommand(YuNil.getInstance());
+    }
+    const char = new YuChar(this.value[this.index]);
+    const tail = new YuString(this.value, this.index + 1);
+    return new StepCommand(new LazyStepResult(char, tail));
+  }
+
+  public size(): ExecutionCommand {
+    return number(this.value.length)
+  }
+
+
+  public plus(other: YuValue): ExecutionCommand {
+    const s = other.asSummable;
+    if (!s) return raise(new UnsupportedOperation(other, "plus"));
+    return s.plusWithString(this);
+  }
+
+  public plusWithNumber(left: YuNumber): ExecutionCommand {
+    return new StepCommand(
+      new YuString(left.toJSON().toString() + this.toJSON()),
+    );
+  }
+
+  public plusWithString(left: YuString): ExecutionCommand {
+    return new StepCommand(new YuString(left.toJSON() + this.toJSON()));
+  }
+
+  public split(): ExecutionCommand {
+    const items = this.toJSON()
+      .split("")
+      .map((char) => new YuChar(char));
+    return new StepCommand(new YuArray(items));
+  }
+
+  public concat(other: YuValue): ExecutionCommand {
+    const seq = other.asSequence
+    if (!seq) return raise(new UnsupportedOperation(other, "concat"));
+    return seq.concatWithString(this)
+  }
+
+  public concatWithString(str: YuString): ExecutionCommand {
+    return new StepCommand(new YuString(str.toJSON() + this.toJSON()));
+  }
+  public concatWithArray(arr: YuArray): ExecutionCommand {
+    return new StepCommand(new YuString(arr.toString()));
+  }
+
+  public realize(): ExecutionCommand {
+    return this.split();
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return boolean(false);
+    return c.equalsWithString(this);
+  }
+
+  public contains(other: YuValue): ExecutionCommand {
+    if (other instanceof YuString) {
+      return boolean(this.value.includes(other.value));
+    }
+    return raise(new UnsupportedOperation(other, "contains"));
+  }
+
+  public equalsWithNumber(left: YuNumber): ExecutionCommand {
+    return new StepCommand(
+      new YuBoolean(left.value.toString() === this.toJSON()),
+    );
+  }
+  public equalsWithBoolean(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithString(left: YuString): ExecutionCommand {
+    return boolean(left.toJSON() === this.toJSON());
+  }
+  public equalsWithArray(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithNil(): ExecutionCommand {
+    return boolean(false);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return raise(new UnsupportedOperation(other, "compare"));
+    return c.compareWithString(this);
+  }
+
+  public compareWithNumber(left: YuNumber): ExecutionCommand {
+    return new StepCommand(new YuNumber(left.value - Number(this.toJSON())));
+  }
+  public compareWithBoolean(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithString(left: YuString): ExecutionCommand {
+    return new StepCommand(
+      new YuNumber(left.toJSON().localeCompare(this.toJSON())),
+    );
+  }
+  public compareWithArray(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithNil(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+
+  public toJSON(): string {
+    return this.index === 0 ? this.value : this.value.slice(this.index);
+  }
+
+  public toString(): string {
+    return this.toJSON();
+  }
+}