yukigo 0.2.3 → 0.3.2

package/src/interpreter/components/PatternMatcher.ts

@@ -1,475 +1,375 @@
-import {
-  ApplicationPattern,
-  AsPattern,
-  ASTNode,
-  ConsPattern,
-  ConstructorPattern,
-  Expression,
-  FunctorPattern,
-  isLazyList,
-  LazyList,
-  ListPattern,
-  ListPrimitive,
-  LiteralPattern,
-  Pattern,
-  PrimitiveValue,
-  TuplePattern,
-  UnionPattern,
-  VariablePattern,
-  Visitor,
-  WildcardPattern,
-  TypePattern,
-  SimpleType,
-  ListType,
-  EnvStack,
-} from "yukigo-ast";
-import { Bindings } from "../index.js";
-import { InterpreterVisitor } from "./Visitor.js";
-import { CPSThunk, Thunk, Continuation } from "../trampoline.js";
-import { RuntimeContext } from "./RuntimeContext.js";
-import { ExpressionEvaluator, getYukigoType } from "../utils.js";
-
-class SharedSequence {
-  private cache: PrimitiveValue[] = [];
-  private source: Generator<PrimitiveValue, void, unknown>;
-  private isDone: boolean = false;
-
-  constructor(
-    generatorFactory: () => Generator<PrimitiveValue, void, unknown>,
-  ) {
-    this.source = generatorFactory();
-  }
-
-  get(index: number): { value: PrimitiveValue | null; done: boolean } {
-    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 interface InternalConsState {
-  readonly head: PrimitiveValue;
-  readonly tailExpr: Expression;
-  readonly evaluator: ExpressionEvaluator;
-  readonly capturedEnv: EnvStack;
-  realizedTail?: PrimitiveValue;
-}
-
-export interface MemoizedLazyList extends LazyList {
-  _sequence: SharedSequence;
-  _offset: number;
-  _consState?: InternalConsState;
-  toJSON: () => any;
-}
-
-export function isMemoizedList(list: unknown): list is MemoizedLazyList {
-  return (
-    list &&
-    typeof list === "object" &&
-    "type" in list &&
-    "_offset" in list &&
-    "_sequence" in list
-  );
-}
-
-export function createMemoizedStream(
-  genFactory: () => Generator<PrimitiveValue, void, unknown>,
-  sequence?: SharedSequence,
-  offset: number = 0,
-): MemoizedLazyList {
-  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: PrimitiveValue[] = [];
-      let next = iterator.next();
-
-      while (!next.done) {
-        buffer.push(next.value);
-        next = iterator.next();
-      }
-
-      return buffer;
-    },
-  };
-}
-
-export class PatternResolver implements Visitor<string> {
-  visitVariablePattern(node: VariablePattern): string {
-    return node.name.value;
-  }
-
-  visitWildcardPattern(node: WildcardPattern): string {
-    return "_";
-  }
-
-  visitLiteralPattern(node: LiteralPattern): string {
-    const { name } = node;
-    if (name instanceof ListPrimitive)
-      return String(name.value.map((elem) => elem.accept(this)));
-    return String(name.value);
-  }
-
-  visitTuplePattern(node: TuplePattern): string {
-    return String(node.elements.map((elem) => elem.accept(this)));
-  }
-
-  visitListPattern(node: ListPattern): string {
-    const { elements } = node;
-    return elements.length === 0
-      ? "[]"
-      : String(elements.map((elem) => elem.accept(this)));
-  }
-
-  visitConsPattern(node: ConsPattern): string {
-    const head = node.left.accept(this);
-    const tail = node.right.accept(this);
-    return `(${head}:${tail})`;
-  }
-
-  visitConstructorPattern(node: ConstructorPattern): string {
-    const constr = node.identifier.value;
-    const args = node.args.map((pat) => pat.accept(this)).join(" ");
-    return `${constr} ${args}`;
-  }
-
-  visitFunctorPattern(node: FunctorPattern): string {
-    // Same as ConstructorPattern (alias)
-    return this.visitConstructorPattern(
-      new ConstructorPattern(node.identifier, node.args),
-    );
-  }
-
-  visitApplicationPattern(node: ApplicationPattern): string {
-    // Same as FunctorPattern
-    return this.visitConstructorPattern(
-      new ConstructorPattern(node.identifier, node.args),
-    );
-  }
-
-  visitAsPattern(node: AsPattern): string {
-    const alias = node.left.accept(this);
-    const pattern = node.right.accept(this);
-    return `${alias}@${pattern}`;
-  }
-
-  visitTypePattern(node: TypePattern): string {
-    const typeStr = node.targetType.toString();
-    return node.innerPattern
-      ? `(${typeStr} ${node.innerPattern.accept(this)})`
-      : typeStr;
-  }
-
-  visit(node: ASTNode): string {
-    return node.accept(this);
-  }
-}
-/**
- * Recursively matches a value against a pattern node.
- * Updates `bindings` when variables are bound successfully.
- * Returns true if the pattern matches, false otherwise.
- */
-export class PatternMatcher implements Visitor<CPSThunk<boolean>> {
-  constructor(
-    private value: PrimitiveValue,
-    private bindings: Bindings,
-    private ctx: RuntimeContext,
-  ) {}
-
-  visitVariablePattern(node: VariablePattern): CPSThunk<boolean> {
-    return (k) => {
-      this.bindings.push([node.name.value, this.value]);
-      return k(true);
-    };
-  }
-
-  visitWildcardPattern(node: WildcardPattern): CPSThunk<boolean> {
-    return (k) => k(true);
-  }
-
-  visitLiteralPattern(node: LiteralPattern): CPSThunk<boolean> {
-    return (k) => {
-      const literalValue = InterpreterVisitor.evaluateLiteral(node.name);
-      return this.ctx.lazyRuntime.deepEqual(this.value, literalValue, k);
-    };
-  }
-
-  visitTuplePattern(node: TuplePattern): CPSThunk<boolean> {
-    return (k) => {
-      const processValue = (val: PrimitiveValue): Thunk<boolean> => {
-        if (!Array.isArray(val)) return k(false);
-        if (val.length !== node.elements.length) return k(false);
-
-        const matchNext = (index: number): Thunk<boolean> => {
-          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: ListPattern): CPSThunk<boolean> {
-    return (k) => {
-      const value = this.value;
-      const neededLength = node.elements.length;
-
-      const finishMatching = (valArr: PrimitiveValue[]): Thunk<boolean> => {
-        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);
-      }
-
-      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);
-    };
-  }
-
-  private matchList(
-    elements: Pattern[],
-    value: PrimitiveValue[],
-    k: Continuation<boolean>,
-  ): Thunk<boolean> {
-    if (value.length !== elements.length) return k(false);
-    const matchNext = (index: number): Thunk<boolean> => {
-      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: ConsPattern): CPSThunk<boolean> {
-    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: TypePattern): CPSThunk<boolean> {
-    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);
-    };
-  }
-
-  private resolveCons(list: PrimitiveValue): [PrimitiveValue, PrimitiveValue] {
-    if (Array.isArray(list)) {
-      if (list.length === 0) return [null, null];
-      const isLazy = this.ctx.config.lazyLoading;
-      if (!isLazy) return [list[0], list.slice(1)];
-      const tail: LazyList = {
-        type: "LazyList",
-        generator: function* () {
-          for (let i = 1; i < list.length; i++) yield list[i];
-        },
-      };
-      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: LazyList = {
-        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: MemoizedLazyList;
-
-      // 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: ConstructorPattern): CPSThunk<boolean> {
-    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: FunctorPattern): CPSThunk<boolean> {
-    return this.visitConstructorPattern(
-      new ConstructorPattern(node.identifier, node.args),
-    );
-  }
-
-  visitApplicationPattern(node: ApplicationPattern): CPSThunk<boolean> {
-    return this.visitConstructorPattern(
-      new ConstructorPattern(node.identifier, node.args),
-    );
-  }
-
-  visitAsPattern(node: AsPattern): CPSThunk<boolean> {
-    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: UnionPattern): CPSThunk<boolean> {
-    return (k) => {
-      const tryNext = (index: number): Thunk<boolean> => {
-        if (index >= node.elements.length) return k(false);
-        const pattern = node.elements[index];
-        const trialBindings: Bindings = [];
-        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: ASTNode): CPSThunk<boolean> {
-    return node.accept(this);
-  }
-}
+import {
+  ApplicationPattern,
+  AsPattern,
+  ASTNode,
+  ConsPattern,
+  ConstructorPattern,
+  FunctorPattern,
+  ListPattern,
+  LiteralPattern,
+  Pattern,
+  TuplePattern,
+  UnionPattern,
+  VariablePattern,
+  WildcardPattern,
+  TypePattern,
+  SimpleType,
+  ListType,
+} from "yukigo-ast";
+import { Bindings } from "../index.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+  BindCommand,
+  FailCommand,
+  RaiseCommand,
+} from "../components/kernel/commands.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+import { boolean, getYukigoType } from "../utils.js";
+import { InterpreterError, UnexpectedNode } from "../errors.js";
+import { EqualityComparer } from "./EqualityComparer.js";
+import {
+  YuValue,
+  YuBoolean,
+  YuArray,
+  isLazyList,
+  YuNil,
+  YuString,
+  LazyList,
+  LazyStepResult,
+  YuChar,
+} from "../primitives/index.js";
+
+/**
+ * Recursively matches a value against a pattern node.
+ * Updates `bindings` when variables are bound successfully.
+ * Returns true if the pattern matches, false otherwise.
+ */
+export class PatternMatcher {
+  constructor(
+    private value: YuValue,
+    private bindings: Bindings,
+    private ctx: RuntimeContext,
+  ) {}
+
+  visitVariablePattern(node: VariablePattern): ExecutionCommand {
+    this.bindings.push([node.name.value, this.value]);
+    return boolean(true);
+  }
+
+  visitWildcardPattern(node: WildcardPattern): ExecutionCommand {
+    return boolean(true);
+  }
+
+  visitLiteralPattern(node: LiteralPattern): ExecutionCommand {
+    return new BindCommand(this.ctx.forceValue(this.value), (val) => {
+      const visitor = this.ctx.evaluatorFactory!(this.ctx);
+      const VisitorClass = visitor.constructor as any;
+      const literalValue = VisitorClass.evaluateLiteral(
+        node.name,
+        this.ctx,
+      );
+      return EqualityComparer.compare(val, literalValue, this.ctx);
+    });
+  }
+
+  visitTuplePattern(node: TuplePattern): ExecutionCommand {
+    return new BindCommand(this.ctx.forceValue(this.value), (forcedVal) => {
+      const processValue = (val: YuValue): ExecutionCommand => {
+        const seq = val.asSequence;
+        if (!(seq instanceof YuArray)) return boolean(false);
+        if (seq.items.length !== node.elements.length) return boolean(false);
+
+        return this.matchList(node.elements, seq, 0);
+      };
+
+      const valSeq = forcedVal.asSequence;
+      if (valSeq && isLazyList(valSeq)) {
+        return new BindCommand(
+          this.ctx.lazyRuntime.realizeList(forcedVal),
+          processValue,
+        );
+      }
+      return processValue(forcedVal);
+    });
+  }
+
+  visitListPattern(node: ListPattern): ExecutionCommand {
+    return new BindCommand(this.ctx.forceValue(this.value), (value) => {
+      const neededLength = node.elements.length;
+
+      const finishMatching = (valArr: YuValue): ExecutionCommand => {
+        const seq = valArr.asSequence;
+        if (!(seq instanceof YuArray))
+          return new RaiseCommand(
+            new InterpreterError(
+              "[PatternMatcher]",
+              `Expected ${valArr} to be a list.`,
+            ),
+          );
+        if (seq.items.length !== neededLength) return boolean(false);
+        return this.matchList(node.elements, seq, 0);
+      };
+
+      if (neededLength === 0) {
+        if (value instanceof YuNil) return boolean(true);
+        const seq = value.asSequence;
+        if (seq) {
+          if (seq instanceof YuArray || seq instanceof YuString) {
+            return new StepCommand(
+              new YuBoolean((seq.toJSON() as any).length === 0),
+            );
+          }
+          if (isLazyList(seq)) {
+            return new BindCommand(seq.step(), (res) =>
+              boolean(res instanceof YuNil),
+            );
+          }
+        }
+        return boolean(false);
+      }
+
+      if (value instanceof YuNil) return boolean(false);
+
+      const seq = value.asSequence;
+      if (seq) {
+        if (seq instanceof YuArray) return finishMatching(value);
+        if (seq instanceof YuString)
+          return new BindCommand(seq.split(), (splitted) =>
+            finishMatching(splitted),
+          );
+
+        if (isLazyList(seq)) {
+          return new BindCommand(
+            this.ctx.lazyRuntime.realizeList(value),
+            finishMatching,
+          );
+        }
+      }
+
+      return boolean(false);
+    });
+  }
+
+  private matchList(
+    elements: Pattern[],
+    value: YuArray,
+    index: number,
+  ): ExecutionCommand {
+    if (index >= elements.length) return boolean(true);
+
+    const matcher = new PatternMatcher(
+      value.at(index),
+      this.bindings,
+      this.ctx,
+    );
+    return new BindCommand(elements[index].accept(matcher), (res) => {
+      const isMatch = res instanceof YuBoolean && res.value;
+      if (!isMatch) return boolean(false);
+      return this.matchList(elements, value, index + 1);
+    });
+  }
+
+  visitConsPattern(node: ConsPattern): ExecutionCommand {
+    return new BindCommand(this.ctx.forceValue(this.value), (forcedVal) => {
+      return new BindCommand(this.resolveCons(forcedVal), (resolved) => {
+        if (!(resolved instanceof YuArray) || resolved.items.length !== 2)
+          return boolean(false);
+        const head = resolved.at(0);
+        const tail = resolved.at(1);
+
+        const headMatcher = new PatternMatcher(head, this.bindings, this.ctx);
+        return new BindCommand(node.left.accept(headMatcher), (headRes) => {
+          const headMatches = headRes instanceof YuBoolean && headRes.value;
+          if (!headMatches) return boolean(false);
+          const tailMatcher = new PatternMatcher(tail, this.bindings, this.ctx);
+          return node.right.accept(tailMatcher);
+        });
+      });
+    });
+  }
+
+  visitTypePattern(node: TypePattern): ExecutionCommand {
+    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 === "List" ||
+        actualType === "Array" ||
+        actualType === "String";
+    }
+
+    if (!matches) return boolean(false);
+
+    if (node.innerPattern) {
+      const innerMatcher = new PatternMatcher(
+        this.value,
+        this.bindings,
+        this.ctx,
+      );
+      return node.innerPattern.accept(innerMatcher);
+    }
+
+    return boolean(true);
+  }
+
+  private resolveCons(val: YuValue): ExecutionCommand {
+    const list = val.asSequence;
+    if (!list) return new StepCommand(YuNil.getInstance());
+
+    if (list instanceof YuArray) {
+      if (list.items.length === 0) return new StepCommand(YuNil.getInstance());
+      const isLazy = this.ctx.config.lazyLoading;
+      if (!isLazy)
+        return new StepCommand(
+          new YuArray([
+            list.at(0),
+            new YuArray(list.items.slice(list.index + 1)),
+          ]),
+        );
+
+      const tail = new LazyList(() => {
+        const next = (arr: YuArray, idx: number): ExecutionCommand => {
+          if (idx >= arr.items.length)
+            return new StepCommand(YuNil.getInstance());
+          return new StepCommand(
+            new LazyStepResult(
+              arr.items[idx],
+              new LazyList(() => next(arr, idx + 1)),
+            ),
+          );
+        };
+        return next(list, list.index + 1);
+      });
+      const arr = new YuArray([list.at(0), tail]);
+      return new StepCommand(arr);
+    }
+
+    if (list instanceof YuString) {
+      const s = list.toJSON();
+      if (s.length === 0) return new StepCommand(YuNil.getInstance());
+
+      const isLazy = this.ctx.config.lazyLoading;
+      if (!isLazy)
+        return new StepCommand(
+          new YuArray([new YuString(s[0]), new YuString(s.slice(1))]),
+        );
+      const tail = new LazyList(() => {
+        const next = (str: string, idx: number): ExecutionCommand => {
+          if (idx >= str.length) return new StepCommand(YuNil.getInstance());
+          return new StepCommand(
+            new LazyStepResult(
+              new YuChar(str[idx]),
+              new LazyList(() => next(str, idx + 1)),
+            ),
+          );
+        };
+        return next(s, 1);
+      });
+      return new StepCommand(new YuArray([new YuChar(s[0]), tail]));
+    }
+
+    // lazy list case
+    if (isLazyList(list)) {
+      return new BindCommand(list.step(), (stepRes) => {
+        if (stepRes.isNil) return new StepCommand(YuNil.getInstance());
+
+        const stepResult = stepRes.asStepResult;
+        if (!stepResult)
+          return new RaiseCommand(
+            new InterpreterError(
+              "PatternMatcher",
+              "step did not return StepResult",
+            ),
+          );
+
+        return new StepCommand(
+          new YuArray([
+            stepResult.head,
+            stepResult.tail || YuNil.getInstance(),
+          ]),
+        );
+      });
+    }
+
+    return new StepCommand(YuNil.getInstance());
+  }
+
+  visitConstructorPattern(node: ConstructorPattern): ExecutionCommand {
+    const seq = this.value.asSequence;
+    if (!(seq instanceof YuArray) || seq.items.length === 0)
+      return boolean(false);
+    const head = seq.at(0);
+    if (!(head instanceof YuString) || head.toJSON() !== node.identifier.value)
+      return boolean(false);
+
+    const args = new YuArray(seq.items.slice(seq.index + 1));
+    return this.matchList(node.args, args, 0);
+  }
+
+  visitFunctorPattern(node: FunctorPattern): ExecutionCommand {
+    return this.visitConstructorPattern(
+      new ConstructorPattern(node.identifier, node.args),
+    );
+  }
+
+  visitApplicationPattern(node: ApplicationPattern): ExecutionCommand {
+    return this.visitConstructorPattern(
+      new ConstructorPattern(node.identifier, node.args),
+    );
+  }
+
+  visitAsPattern(node: AsPattern): ExecutionCommand {
+    const innerMatcher = new PatternMatcher(
+      this.value,
+      this.bindings,
+      this.ctx,
+    );
+
+    return new BindCommand(node.right.accept(innerMatcher), (res) => {
+      const innerMatches = res instanceof YuBoolean && res.value;
+      if (!innerMatches) return boolean(false);
+
+      const aliasMatcher = new PatternMatcher(
+        this.value,
+        this.bindings,
+        this.ctx,
+      );
+      return node.left.accept(aliasMatcher);
+    });
+  }
+
+  visitUnionPattern(node: UnionPattern): ExecutionCommand {
+    const tryNext = (index: number): ExecutionCommand => {
+      if (index >= node.elements.length) return boolean(false);
+
+      const pattern = node.elements[index];
+      const trialBindings: Bindings = [];
+      const matcher = new PatternMatcher(this.value, trialBindings, this.ctx);
+
+      return new BindCommand(pattern.accept(matcher), (res) => {
+        const isMatch = res instanceof YuBoolean && res.value;
+        if (isMatch) {
+          this.bindings.push(...trialBindings);
+          return boolean(true);
+        }
+        return tryNext(index + 1);
+      });
+    };
+
+    return tryNext(0);
+  }
+
+  visit(node: ASTNode): ExecutionCommand {
+    return node.accept(this);
+  }
+  public fallback(node: ASTNode): ExecutionCommand {
+    return new FailCommand(
+      new UnexpectedNode(node.constructor.name, "PatternMatcher"),
+    );
+  }
+}