@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/source.js

@@ -1,8 +1,8 @@
-import { WeakStackFrame } from '@bablr/weak-stack';
-import { maybeWait, getStreamIterator, emptyStreamIterator } from '@bablr/agast-helpers/stream';
+import { maybeWait, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { facades, actuals } from './facades.js';
+import { streamIteratorSymbol } from '@bablr/stream-iterator';
 
-// Queue item instances are shared between all forks.
+// Queue item instances are shared between all sources.
 class QueueItem {
   constructor(step) {
     this.step = step;
@@ -17,7 +17,7 @@ class Exchange {
     this.iterator = iterator;
     this.tail = new QueueItem(null);
     this.head = this.tail;
-    this.forks = 0;
+    this.sources = 0;
   }
 
   static from(iterable) {
@@ -28,10 +28,19 @@ class Exchange {
     return this.head.step instanceof Promise;
   }
 
-  allocateFork(fork) {
-    const { head = this.tail, exchange = this, current } = fork || {};
-    ++this.forks;
-    return new Fork(head, exchange, current);
+  allocateSource(source) {
+    const { head = this.tail, exchange = this, index, holding, prevValue } = source || {};
+    ++this.sources;
+    return new Source(head, exchange, index, holding, prevValue);
+  }
+
+  releaseSource(source) {
+    --this.sources;
+    if (this.sources === 0) {
+      this.iterator.return?.();
+    }
+    source.exchange = null;
+    return { value: undefined, done: true };
   }
 
   advance() {
@@ -44,7 +53,6 @@ class Exchange {
     if (step instanceof Promise) {
       step = step.then((step) => {
         newItem.step = step;
-        return step;
       });
     }
 
@@ -55,99 +63,47 @@ class Exchange {
 
     return newItem;
   }
+}
 
-  releaseFork(fork) {
-    --this.forks;
-    if (this.forks === 0) {
-      this.iterator.return?.();
-    }
-    return { value: undefined, done: true };
+let sources = new WeakMap();
+
+class SourceIterator {
+  static from(source) {
+    const { exchange } = source;
+    return source.done
+      ? sources.get(source) ?? new SourceIterator(source)
+      : new SourceIterator(exchange.allocateSource(source));
   }
-}
 
-class ForkIterator {
-  constructor(fork) {
-    facades.set(fork.clone(), this);
+  constructor(source) {
+    sources.set(this, source);
   }
 
   next() {
-    const fork = actuals.get(this);
-    if (!fork.done) {
-      const { head } = fork;
-      fork.advance();
-      return maybeWait(fork.head.step, () => head.step);
+    const source = sources.get(this);
+    if (!source.done) {
+      const { holding, head } = source;
+      source.advance();
+      return maybeWait(source.head.step, () => {
+        return holding ? { value: null, done: false } : head.step;
+      });
     } else {
       return { value: undefined, done: true };
     }
   }
 
   return() {
-    actuals.get(this).return();
+    sources.get(this).release();
+
     return { value: undefined, done: true };
   }
 
-  [Symbol.for('@@streamIterator')]() {
+  [Symbol.iterator]() {
     return this;
   }
-}
-
-class Fork {
-  constructor(head, exchange, done = false) {
-    this.head = head; // QueueItem
-    this.exchange = exchange;
-    this._done = done;
-  }
-
-  get done() {
-    return this._done || this.head.step?.done;
-  }
-
-  get value() {
-    return this.done ? { value: undefined, done: true } : this.head.step?.value;
-  }
-
-  advance() {
-    const { exchange } = this;
-
-    if (this.done) {
-      throw new Error('cannot advance a fork that is done');
-    } else {
-      let { head } = this;
-
-      let nextItem = this.head.next;
-
-      if (!head.step?.done) {
-        if (!nextItem) {
-          nextItem = exchange.fetch();
-        }
-
-        this.head = nextItem;
-      }
-
-      return nextItem;
-    }
-  }
-
-  return() {
-    const { done, exchange } = this;
-
-    if (!done) exchange.releaseFork(this);
 
-    const step = { value: undefined, done: true };
-
-    this._current = step;
-
-    return step;
-  }
-
-  clone() {
-    const { exchange } = this;
-
-    return exchange.allocateFork(this);
-  }
-
-  [Symbol.for('@@streamIterator')]() {
-    return new ForkIterator(this);
+  [streamIteratorSymbol]() {
+    return this;
   }
 }
 
@@ -158,10 +114,12 @@ export const SourceFacade = class BABLRSourceFacade {
 
   constructor(source) {
     facades.set(source, this);
+
+    Object.freeze(this);
   }
 
-  [Symbol.for('@@streamIterator')]() {
-    return actuals.get(this)[Symbol.for('@@streamIterator')]();
+  [streamIteratorSymbol]() {
+    return actuals.get(this)[streamIteratorSymbol]();
   }
 
   get done() {
@@ -181,47 +139,36 @@ export const SourceFacade = class BABLRSourceFacade {
   }
 };
 
-export const Source = class BABLRSource extends WeakStackFrame {
+export const Source = class BABLRSource {
   static from(iterable) {
     const exchange = Exchange.from(iterable);
-    return Source.create(exchange.allocateFork(), exchange);
+    return exchange.allocateSource();
   }
 
-  constructor(parent, fork, exchange, index = -1, holding = false) {
-    super(parent);
-
-    if (!fork || !exchange) throw new Error();
+  constructor(head, exchange, index = -1, holding = false, prevValue = undefined) {
+    if (!head || !exchange) throw new Error();
 
-    this.fork = fork;
+    this.head = head;
     this.exchange = exchange;
     this.index = index;
     this.holding = holding;
+    this.prevValue = prevValue;
 
     new SourceFacade(this);
   }
 
   get value() {
-    return this.holding ? null : this.fork.value;
+    return this.holding ? null : this.head.step?.value;
   }
 
   get done() {
-    return this.fork.done;
+    return !this.exchange || this.head.step?.done;
   }
 
   get atGap() {
     return this.holding || (!this.done && this.value == null);
   }
 
-  advance(n = 1) {
-    return new Array(n).fill(null).reduce((acc) => {
-      return maybeWait(acc, () => {
-        this.fork.advance();
-        this.index++;
-        return this.fork.step;
-      });
-    }, this.fork.step);
-  }
-
   shift() {
     this.holding = true;
   }
@@ -230,30 +177,80 @@ export const Source = class BABLRSource extends WeakStackFrame {
     this.holding = false;
   }
 
+  advance(n = 1) {
+    let { exchange } = this;
+
+    if (this.holding) {
+      this.holding = false;
+      n--;
+    }
+
+    return new Array(n).fill(null).reduce((acc) => {
+      return maybeWait(acc, () => {
+        if (this.done) {
+          throw new Error('cannot advance a source that is done');
+        } else {
+          let { head, value } = this;
+
+          let nextItem = head.next;
+
+          if (!this.done) {
+            if (!nextItem) {
+              nextItem = exchange.fetch();
+            }
+
+            this.head = head = nextItem;
+            this.prevValue = value;
+
+            if (head.step?.done) {
+              exchange.releaseSource(this);
+            }
+          }
+        }
+
+        this.index++;
+        return this.head.step;
+      });
+    }, this.head.step);
+  }
+
   branch() {
-    const { fork, exchange, index, holding } = this;
-    return this.push(exchange.allocateFork(fork), exchange, index, holding);
+    const { exchange } = this;
+
+    return exchange ? exchange.allocateSource(this) : this;
   }
 
   release() {
-    this.fork.return();
+    const { exchange, head } = this;
+
+    if (exchange) exchange.releaseSource(this);
+
+    const step = { value: undefined, done: true };
+
+    this.head = { ...head, step };
+
+    return step;
   }
 
   accept(source) {
-    this.release();
-    this.fork = source.fork;
+    this.head = source.head;
     this.index = source.index;
     this.holding = source.holding;
+    this.prevValue = source.prevValue;
+
+    source.release();
   }
 
   reject() {
     this.release();
   }
 
-  [Symbol.for('@@streamIterator')]() {
-    return (this.holding ? emptyStreamIterator() : this.fork.clone())[
-      Symbol.for('@@streamIterator')
-    ]();
+  [Symbol.iterator]() {
+    return SourceIterator.from(this);
+  }
+
+  [streamIteratorSymbol]() {
+    return SourceIterator.from(this);
   }
 
   formatIndex() {

package/lib/spans.js

@@ -1,15 +1,12 @@
 import { ReferenceTag } from '@bablr/agast-helpers/symbols';
-import { getOpenTag } from '@bablr/agast-helpers/tree';
 
 export function updateSpans(m, node, phase) {
   const { state: s } = m;
-  const { flags, attributes } = node;
+  const { attributes } = node;
   const refPath = m.reference;
 
   if (refPath && refPath.tag.type !== ReferenceTag) throw new Error();
 
-  const openTag = getOpenTag(node);
-
   const intrinsic = !refPath || (refPath.tag.type === ReferenceTag && !refPath.tag.value.hasGap);
 
   switch (phase) {