@fncts/base 0.0.31 → 0.0.33

package/_src/collection/immutable/HashMap/internal.ts

@@ -135,7 +135,12 @@ export type UpdateFn<V> = (v: Maybe<V>) => Maybe<V>;
 
 export class LeafNode<K, V> {
   readonly _tag = "LeafNode";
-  constructor(readonly edit: number, readonly hash: number, readonly key: K, public value: Maybe<V>) {}
+  constructor(
+    readonly edit: number,
+    readonly hash: number,
+    readonly key: K,
+    public value: Maybe<V>,
+  ) {}
 
   modify(
     edit: number,
@@ -169,7 +174,11 @@ export class LeafNode<K, V> {
 
 export class CollisionNode<K, V> {
   readonly _tag = "CollisionNode";
-  constructor(public edit: number, public hash: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,
@@ -227,7 +236,11 @@ function updateCollisionList<K, V>(
 
 export class IndexedNode<K, V> {
   readonly _tag = "IndexedNode";
-  constructor(public edit: number, public mask: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public mask: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,
@@ -281,7 +294,11 @@ export class IndexedNode<K, V> {
 
 export class ArrayNode<K, V> {
   readonly _tag = "ArrayNode";
-  constructor(public edit: number, public size: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public size: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,

package/_src/collection/immutable/HashMap.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: HashMap/*.ts, exclude: HashMap/internal.ts }
-export * from "./HashMap/api.js";
 export * from "./HashMap/definition.js";
+export * from "./HashMap/api.js";
 // codegen:end

package/_src/collection/immutable/HashSet/api.ts

@@ -300,14 +300,14 @@ export function partitionMapWith<B, C>(
     const right = beginMutation(emptyWith(C));
     const left  = beginMutation(emptyWith(B));
     fa.forEach((v) => {
-      f(v).match(
-        (b) => {
+      f(v).match({
+        Left: (b) => {
           left.add(b);
         },
-        (c) => {
+        Right: (c) => {
           right.add(c);
         },
-      );
+      });
     });
     return [endMutation(left), endMutation(right)];
   };

package/_src/collection/immutable/HashSet/definition.ts

@@ -84,7 +84,10 @@ export function isHashSet(u: unknown): u is HashSet<unknown> {
 class HashSetIterator<A, T> implements IterableIterator<T> {
   v: VisitResult<A, T> | undefined;
 
-  constructor(readonly set: HashSet<A>, readonly f: (node: A) => T) {
+  constructor(
+    readonly set: HashSet<A>,
+    readonly f: (node: A) => T,
+  ) {
     this.v = visitLazy(this.set._root, this.f, undefined);
   }
 
@@ -144,7 +147,11 @@ export function isEmptyNode<A>(n: Node<A>): n is EmptyNode<A> {
 
 export class LeafNode<A> {
   readonly _tag = "LeafNode";
-  constructor(public edit: number, public hash: number, public value: A) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public value: A,
+  ) {}
 
   modify(
     remove: boolean,
@@ -179,7 +186,11 @@ export class LeafNode<A> {
 
 export class CollisionNode<A> {
   readonly _tag = "CollisionNode";
-  constructor(public edit: number, public hash: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public children: Array<Node<A>>,
+  ) {}
   modify(
     remove: boolean,
     edit: number,
@@ -234,7 +245,11 @@ export function isLeaf<A>(node: Node<A>): node is EmptyNode<A> | LeafNode<A> | C
 
 export class IndexedNode<A> {
   readonly _tag = "IndexedNode";
-  constructor(public edit: number, public mask: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public mask: number,
+    public children: Array<Node<A>>,
+  ) {}
 
   modify(
     remove: boolean,
@@ -283,7 +298,11 @@ export class IndexedNode<A> {
 
 export class ArrayNode<A> {
   readonly _tag = "ArrayNode";
-  constructor(public edit: number, public size: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public size: number,
+    public children: Array<Node<A>>,
+  ) {}
   modify(
     remove: boolean,
     edit: number,

package/_src/collection/immutable/HashSet.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: HashSet/*.ts }
-export * from "./HashSet/api.js";
 export * from "./HashSet/definition.js";
+export * from "./HashSet/api.js";
 // codegen:end

package/_src/collection/immutable/ImmutableArray/api.ts

@@ -1430,16 +1430,16 @@ export function _wiltWithIndex<A>(self: ImmutableArray<A>) {
         .foldLeftWithIndex(G.pure([[] as Array<B>, [] as Array<B2>] as const), (i, fbs, a) =>
           f(i, a).pipe(
             G.zipWith(fbs, (eb, r) =>
-              eb.match(
-                (b1) => {
+              eb.match({
+                Left: (b1) => {
                   r[0].push(b1);
                   return r;
                 },
-                (b2) => {
+                Right: (b2) => {
                   r[1].push(b2);
                   return r;
                 },
-              ),
+              }),
             ),
           ),
         )

package/_src/collection/immutable/ImmutableArray.ts

@@ -1,13 +1,15 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./ImmutableArray/*.ts }
-export * from "./ImmutableArray/api.js";
-export * from "./ImmutableArray/constructors.js";
-export * from "./ImmutableArray/definition.js";
 export * from "./ImmutableArray/instances.js";
+export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/constructors.js";
+export * from "./ImmutableArray/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./ImmutableArray/api/*.ts }
-export * from "./ImmutableArray/api/chunksOf.js";
-export * from "./ImmutableArray/api/slice.js";
-export * from "./ImmutableArray/api/splitAt.js";
 export * from "./ImmutableArray/api/splitWhere.js";
+export * from "./ImmutableArray/api/splitAt.js";
+export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/api/chunksOf.js";
 // codegen:end

package/_src/collection/immutable/ImmutableNonEmptyArray.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ImmutableNonEmptyArray/*.ts }
-export * from "./ImmutableNonEmptyArray/api.js";
-export * from "./ImmutableNonEmptyArray/constructors.js";
-export * from "./ImmutableNonEmptyArray/definition.js";
-export * from "./ImmutableNonEmptyArray/destructors.js";
 export * from "./ImmutableNonEmptyArray/instances.js";
+export * from "./ImmutableNonEmptyArray/destructors.js";
+export * from "./ImmutableNonEmptyArray/definition.js";
+export * from "./ImmutableNonEmptyArray/constructors.js";
+export * from "./ImmutableNonEmptyArray/api.js";
 // codegen:end

package/_src/collection/immutable/List/definition.ts

@@ -22,7 +22,10 @@ export type ListTypeId = typeof ListTypeId;
 export class Cons<A> implements Iterable<A> {
   readonly _tag                     = "Cons";
   readonly [ListTypeId]: ListTypeId = ListTypeId;
-  constructor(readonly head: A, public tail: List<A> = _Nil) {}
+  constructor(
+    readonly head: A,
+    public tail: List<A> = _Nil,
+  ) {}
 
   [Symbol.iterator](): Iterator<A> {
     let done = false;

package/_src/collection/immutable/List.ts

@@ -1,9 +1,11 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: List/*.ts }
-export * from "./List/api.js";
-export * from "./List/constructors.js";
 export * from "./List/definition.js";
+export * from "./List/constructors.js";
+export * from "./List/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: "./List/api/*.ts" }
-export * from "./List/api/foldLeft.js";
 export * from "./List/api/unsafeTail.js";
+export * from "./List/api/foldLeft.js";
 // codegen:end

package/_src/collection/immutable/Queue.ts

@@ -1,6 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Queue/*.ts }
-export * from "./Queue/api.js";
-export * from "./Queue/constructors.js";
-export * from "./Queue/definition.js";
 export * from "./Queue/guards.js";
+export * from "./Queue/definition.js";
+export * from "./Queue/constructors.js";
+export * from "./Queue/api.js";
 // codegen:end

package/_src/collection/immutable/RoseTree/definition.ts

@@ -20,7 +20,10 @@ export class RoseTree<A> implements Hashable, Equatable {
   declare [RoseTreeVariance]: {
     readonly _A: (_: never) => A;
   };
-  constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
+  constructor(
+    readonly value: A,
+    readonly forest: Vector<RoseTree<A>>,
+  ) {}
 
   [Symbol.equals](that: unknown): boolean {
     return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;

package/_src/collection/immutable/RoseTree.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./RoseTree/*.ts }
-export * from "./RoseTree/api.js";
 export * from "./RoseTree/definition.js";
+export * from "./RoseTree/api.js";
 // codegen:end

package/_src/collection/immutable/SortedMap/definition.ts

@@ -14,7 +14,10 @@ export type TypeId = typeof TypeId;
 export class SortedMap<K, V> implements SortedMapIterable<K, V> {
   readonly [TypeId]: TypeId = TypeId;
 
-  constructor(readonly ord: Ord<K>, readonly root: RBNode<K, V>) {}
+  constructor(
+    readonly ord: Ord<K>,
+    readonly root: RBNode<K, V>,
+  ) {}
 
   [Symbol.iterator](): SortedMapIterator<K, V> {
     return forward(this)[Symbol.iterator]();

package/_src/collection/immutable/SortedMap/iterator.ts

@@ -41,7 +41,11 @@ export function backward<K, V>(self: SortedMap<K, V>): SortedMapIterable<K, V> {
 
 export class SortedMapIterator<K, V> implements Iterator<readonly [K, V]> {
   private count = 0;
-  constructor(readonly m: SortedMap<K, V>, readonly stack: Array<Node<K, V>>, readonly direction: 0 | 1) {}
+  constructor(
+    readonly m: SortedMap<K, V>,
+    readonly stack: Array<Node<K, V>>,
+    readonly direction: 0 | 1,
+  ) {}
 
   next(): IteratorResult<readonly [K, V]> {
     if (this.isEmpty) {

package/_src/collection/immutable/SortedMap.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./SortedMap/*.ts }
-export * from "./SortedMap/api.js";
-export * from "./SortedMap/definition.js";
-export * from "./SortedMap/internal.js";
-export * from "./SortedMap/iterator.js";
 export * from "./SortedMap/node.js";
+export * from "./SortedMap/iterator.js";
+export * from "./SortedMap/internal.js";
+export * from "./SortedMap/definition.js";
+export * from "./SortedMap/api.js";
 // codegen:end

package/_src/collection/immutable/Vector/internal.ts

@@ -18,7 +18,10 @@ export abstract class VectorIterator<A> implements Iterator<A> {
   prefixSize: number;
   middleSize: number;
   result: IteratorResult<A> = { done: false, value: undefined as any };
-  constructor(protected l: Vector<A>, direction: 1 | -1) {
+  constructor(
+    protected l: Vector<A>,
+    direction: 1 | -1,
+  ) {
     this.idx        = direction === 1 ? -1 : l.length;
     this.prefixSize = getPrefixSize(l);
     this.middleSize = l.length - getSuffixSize(l);
@@ -130,7 +133,10 @@ type Sizes = number[] | undefined;
 
 /** @internal */
 export class Node {
-  constructor(public sizes: Sizes, public array: any[]) {}
+  constructor(
+    public sizes: Sizes,
+    public array: any[],
+  ) {}
 }
 
 /**

package/_src/collection/immutable/Vector.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: ./Vector/internal.ts }
-export * from "./Vector/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: Vector/internal.ts }
 export * from "./Vector/definition.js";
+export * from "./Vector/api.js";
 // codegen:end

package/_src/collection/immutable.ts

@@ -1,13 +1,14 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./immutable/*.ts }
-export type {} from "./immutable/Conc.js";
-export type {} from "./immutable/Dictionary.js";
-export type {} from "./immutable/HashMap.js";
-export type {} from "./immutable/HashSet.js";
-export type {} from "./immutable/ImmutableArray.js";
-export type {} from "./immutable/ImmutableNonEmptyArray.js";
-export type {} from "./immutable/List.js";
-export type {} from "./immutable/Queue.js";
-export type {} from "./immutable/RoseTree.js";
-export type {} from "./immutable/SortedMap.js";
 export type {} from "./immutable/Vector.js";
+export type {} from "./immutable/SortedMap.js";
+export type {} from "./immutable/RoseTree.js";
+export type {} from "./immutable/Queue.js";
+export type {} from "./immutable/List.js";
+export type {} from "./immutable/ImmutableNonEmptyArray.js";
+export type {} from "./immutable/ImmutableArray.js";
+export type {} from "./immutable/HashSet.js";
+export type {} from "./immutable/HashMap.js";
+export type {} from "./immutable/Dictionary.js";
+export type {} from "./immutable/Conc.js";
 // codegen:end

package/_src/collection/mutable/ArrayDeque.ts

@@ -0,0 +1,235 @@
+const STABLE_SIZE          = 128;
+const DEFAULT_INITIAL_SIZE = 16;
+
+/**
+ * @tsplus type fncts.MutableArrayDeque
+ * @tsplus companion fncts.MutableArrayDeque
+ */
+export class ArrayDeque<A> {
+  constructor(
+    protected array: Array<A>,
+    private start: number,
+    private end: number,
+  ) {}
+
+  static empty<A>(initialSize = DEFAULT_INITIAL_SIZE): ArrayDeque<A> {
+    return new ArrayDeque(new Array(initialSize), 0, 0);
+  }
+
+  protected requireBounds(idx: number, until: number = this.length) {
+    if (idx < 0 || idx > until) throw new IndexOutOfBoundsError(`${idx} is out of bounds (min 0, max ${until - 1})`);
+  }
+
+  get(idx: number): A {
+    this.requireBounds(idx);
+    return this._get(idx);
+  }
+
+  update(idx: number, elem: A): void {
+    this.requireBounds(idx);
+    this._set(idx, elem);
+  }
+
+  addOne(elem: A): this {
+    this.ensureSize(this.length + 1);
+    return this.appendAssumingCapacity(elem);
+  }
+
+  prepend(elem: A): this {
+    this.ensureSize(this.length + 1);
+    return this.prependAssumingCapacity(elem);
+  }
+
+  insert(idx: number, elem: A): void {
+    this.requireBounds(idx, this.length + 1);
+    const n = this.length;
+    if (idx === 0) {
+      this.prepend(elem);
+    } else if (idx === n) {
+      this.addOne(elem);
+    } else {
+      const finalLength = n + 1;
+      if (this.mustGrow(finalLength)) {
+        const array2 = new Array(finalLength);
+        this.copySliceToArray(0, array2, 0, idx);
+        array2[idx] = elem;
+        this.copySliceToArray(idx, array2, idx + 1, n);
+        this.reset(array2, 0, finalLength);
+      } else if (n <= idx * 2) {
+        let i = n - 1;
+        for (; i >= idx; i--) {
+          this._set(i + 1, this._get(i));
+        }
+        this.end = this.end_plus(1);
+        i       += 1;
+        this._set(i, elem);
+      } else {
+        let i = 0;
+        for (; i < idx; i++) {
+          this._set(i - 1, this._get(1));
+        }
+        this.start = this.start_minus(1);
+        this._set(i, elem);
+      }
+    }
+  }
+
+  remove(idx: number, count: number): void {
+    if (count > 0) {
+      this.requireBounds(idx);
+      const n           = this.length;
+      const removals    = Math.min(n - idx, count);
+      const finalLength = n - removals;
+      const suffixStart = idx + removals;
+      if (this.shouldShrink(finalLength)) {
+        const array2 = new Array(finalLength);
+        this.copySliceToArray(0, array2, 0, idx);
+        this.copySliceToArray(suffixStart, array2, idx, n);
+        this.reset(array2, 0, finalLength);
+      } else if (2 * idx <= finalLength) {
+        let i = suffixStart - 1;
+        for (; i >= removals; i--) {
+          this._set(i, this._get(i - removals));
+        }
+        for (; i >= 0; i--) {
+          this._set(i, null!);
+        }
+        this.start = this.start_plus(removals);
+      } else {
+        let i = idx;
+        for (; i < finalLength; i++) {
+          this._set(i, this._get(i + removals));
+        }
+        for (; i < n; i++) {
+          this._set(i, null!);
+        }
+        this.end = this.end_minus(removals);
+      }
+    } else if (count < 0) {
+      throw new Error(`Removing negative number of elements ${count}`);
+    }
+  }
+
+  removeHead(resizeInternalRepr = false): A {
+    if (this.isEmpty) throw new NoSuchElementError("empty collection");
+    else return this.removeHeadAssumingNonEmpty(resizeInternalRepr);
+  }
+
+  removeHeadOption(resizeInternalRepr = false): Maybe<A> {
+    if (this.isEmpty) return Nothing();
+    else return Just(this.removeHeadAssumingNonEmpty(resizeInternalRepr));
+  }
+
+  removeLastOption(resizeInternalRepr = false): Maybe<A> {
+    if (this.isEmpty) return Nothing();
+    else return Just(this.removeLastAssumingNonEmpty(resizeInternalRepr));
+  }
+
+  get isEmpty(): boolean {
+    return this.length === 0;
+  }
+
+  private removeHeadAssumingNonEmpty(resizeInternalRepr = false): A {
+    const elem             = this.array[this.start];
+    this.array[this.start] = null!;
+    this.start             = this.start_plus(1);
+    if (resizeInternalRepr) this.resize(this.length);
+    return elem!;
+  }
+
+  private removeLastAssumingNonEmpty(resizeInternalRepr = false): A {
+    this.end             = this.end_minus(1);
+    const elem           = this.array[this.end];
+    this.array[this.end] = null!;
+    if (resizeInternalRepr) this.resize(this.length);
+    return elem!;
+  }
+
+  protected prependAssumingCapacity(elem: A): this {
+    this.start             = this.start_minus(1);
+    this.array[this.start] = elem;
+    return this;
+  }
+
+  protected appendAssumingCapacity(elem: A): this {
+    this.array[this.end] = elem;
+    this.end             = this.end_plus(1);
+    return this;
+  }
+
+  private ensureSize(hint: number) {
+    if (hint > this.length && this.mustGrow(hint)) {
+      this.resize(hint);
+    }
+  }
+
+  private resize(len: number) {
+    const n      = this.length;
+    const array2 = this.copySliceToArray(0, new Array(len), 0, n);
+    this.reset(array2, 0, n);
+  }
+
+  private reset(array: Array<A>, start: number, end: number) {
+    this.requireBounds(start, array.length);
+    this.requireBounds(end, array.length);
+    this.array = array;
+    this.start = start;
+    this.end   = end;
+  }
+
+  private mustGrow(len: number) {
+    return len >= this.array.length;
+  }
+
+  protected start_plus(idx: number) {
+    return (this.start + idx) & (this.array.length - 1);
+  }
+
+  private start_minus(idx: number) {
+    return (this.start - idx) & (this.array.length - 1);
+  }
+
+  private end_plus(idx: number) {
+    return (this.end + idx) & (this.array.length - 1);
+  }
+
+  private end_minus(idx: number) {
+    return (this.end - idx) & (this.array.length - 1);
+  }
+
+  private _get(idx: number): A {
+    return this.array[this.start_plus(idx)]!;
+  }
+
+  private _set(idx: number, a: A): void {
+    this.array[this.start_plus(idx)] = a;
+  }
+
+  get length() {
+    return this.end_minus(this.start);
+  }
+
+  copySliceToArray(srcStart: number, dest: Array<A>, destStart: number, maxItems: number): Array<A> {
+    this.requireBounds(destStart, dest.length + 1);
+    const toCopy = Math.min(maxItems, Math.min(this.length - srcStart, dest.length - destStart));
+    if (toCopy > 0) {
+      this.requireBounds(srcStart);
+      const startIdx = this.start_plus(srcStart);
+      const block1   = Math.min(toCopy, this.array.length - startIdx);
+      copyArray(this.array, startIdx, dest, destStart, block1);
+      const block2 = toCopy - block1;
+      if (block2 > 0) copyArray(this.array, 0, dest, destStart + block1, block2);
+    }
+    return dest;
+  }
+
+  private shouldShrink(len: number) {
+    return this.array.length > STABLE_SIZE && this.array.length - len - (len >> 1) > len;
+  }
+}
+
+function copyArray<A>(src: Array<A>, srcPos: number, dest: Array<A>, destPos: number, length: number): void {
+  for (let i = srcPos, j = 0; j < length; i++, j++) {
+    dest[destPos + j] = src[i]!;
+  }
+}

package/_src/collection/mutable/HashMap.ts

@@ -281,7 +281,12 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
 }
 
 class Node<K, V> {
-  constructor(public key: K, public hash: number, public value: V, public next: Node<K, V> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public value: V,
+    public next: Node<K, V> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K, V> | undefined {
     let n: Node<K, V> | undefined = this;
@@ -309,7 +314,10 @@ export class HashMapIterator<K, V, A> implements Iterator<A> {
   private i = 0;
   private len: number;
   private done = false;
-  constructor(private table: Array<Node<K, V> | undefined>, private extract: (nd: Node<K, V>) => A) {
+  constructor(
+    private table: Array<Node<K, V> | undefined>,
+    private extract: (nd: Node<K, V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable/HashSet.ts

@@ -188,7 +188,11 @@ export class HashSet<A> implements Iterable<A> {
 }
 
 class Node<K> {
-  constructor(public key: K, public hash: number, public next: Node<K> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public next: Node<K> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K> | undefined {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -218,7 +222,10 @@ export class HashSetIterator<V, A> implements Iterator<A> {
   private len: number;
   private i    = 0;
   private done = false;
-  constructor(private table: Array<Node<V> | undefined>, private extract: (nd: Node<V>) => A) {
+  constructor(
+    private table: Array<Node<V> | undefined>,
+    private extract: (nd: Node<V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable/Queue.ts

@@ -0,0 +1,14 @@
+import { ArrayDeque } from "@fncts/base/collection/mutable/ArrayDeque";
+
+/**
+ * @tsplus type fncts.MutableQueue
+ * @tsplus companion fncts.MutableQueue
+ */
+export class Queue<A> extends ArrayDeque<A> {
+  enqueue(elem: A): this {
+    return this.addOne(elem);
+  }
+  dequeue(): A {
+    return this.removeHead();
+  }
+}