@fncts/base 0.0.1

package/_src/collection/immutable/Vector.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: ./Vector/internal.ts }
+export * from "./Vector/api.js";
+export * from "./Vector/definition.js";
+// codegen:end

package/_src/collection/mutable/HashMap.ts

@@ -0,0 +1,338 @@
+/*
+ * This file contains software ported from:
+ *
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the doc/LICENSE.md file in the root of this source tree
+ * for more information regarding copyright ownership
+ */
+
+import { copyOfArray, improveHash, tableSizeFor } from "@fncts/base/collection/mutable/internal";
+import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { assert } from "@fncts/base/util/assert";
+
+const DEFAULT_INITIAL_CAPACITY = 16;
+const DEFAULT_LOAD_FACTOR      = 0.75;
+
+/**
+ * @tsplus type fncts.MutableHashMap
+ * @tsplus companion fncts.MutableHashMapOps
+ */
+export class HashMap<K, V> implements Iterable<readonly [K, V]> {
+  constructor(
+    private initialCapacity: number,
+    private loadFactor: number,
+    private config: HashEq<K> = HashEq.StructuralStrict,
+  ) {
+    this.table = new Array<Node<K, V> | undefined>(tableSizeFor(this.initialCapacity));
+
+    this.threshold = this.newThreshold(this.table.length);
+  }
+
+  [Symbol.iterator](): Iterator<readonly [K, V]> {
+    return new HashMapIterator(this.table, (nd) => [nd.key, nd.value]);
+  }
+
+  static empty<K, V>(config?: HashEq<K>): HashMap<K, V> {
+    return new HashMap(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, config);
+  }
+
+  private table: Array<Node<K, V> | undefined>;
+
+  private threshold: number;
+
+  private contentSize = 0;
+
+  get size(): number {
+    return this.contentSize;
+  }
+
+  has(key: K): boolean {
+    return this.findNode(key) !== undefined;
+  }
+
+  get(key: K): Maybe<V> {
+    const n = this.findNode(key);
+    return n ? Just(n.value) : Nothing();
+  }
+
+  set(key: K, value: V): Maybe<V> {
+    return this._set(key, value, true);
+  }
+
+  delete(key: K): Maybe<V> {
+    const n = this._delete(key);
+    return n ? Just(n.value) : Nothing();
+  }
+
+  updateWith(key: K, f: (v: Maybe<V>) => Maybe<V>): Maybe<V> {
+    const hash                               = this.computeHash(key);
+    const indexedHash                        = this.index(hash);
+    let foundNode: Node<K, V> | undefined    = undefined;
+    let previousNode: Node<K, V> | undefined = undefined;
+    const n = this.table[indexedHash];
+    if (n) {
+      let prev: Node<K, V> | undefined = undefined;
+      let nd: Node<K, V> | undefined   = n;
+      while (nd) {
+        if (hash === nd.hash && this.config.equals_(key, nd.key)) {
+          previousNode = prev;
+          foundNode    = nd;
+          break;
+        } else if (nd.next === undefined || nd.hash > hash) {
+          break;
+        } else {
+          prev = nd;
+          nd   = nd.next;
+        }
+      }
+    }
+    const previousValue = foundNode === undefined ? Nothing() : Just(foundNode.value);
+    const nextValue     = f(previousValue);
+    previousValue.match(
+      () =>
+        nextValue.match(
+          () => {
+            /* do nothing */
+          },
+          (value) => {
+            const newIndexedHash =
+              this.contentSize + 1 > this.threshold
+                ? (this.growTable(this.table.length * 2), this.index(hash))
+                : indexedHash;
+            this._set0(key, value, false, hash, newIndexedHash);
+          },
+        ),
+      () =>
+        nextValue.match(
+          () => {
+            if (previousNode !== undefined) {
+              previousNode.next = foundNode!.next;
+            } else {
+              this.table[indexedHash] = foundNode!.next;
+            }
+            this.contentSize -= 1;
+          },
+          (newValue) => {
+            foundNode!.value = newValue;
+          },
+        ),
+    );
+    return nextValue;
+  }
+
+  forEach<U>(f: (k: K, v: V) => U): void {
+    for (let i = 0; i < this.table.length; i++) {
+      const n = this.table[i];
+      if (n) n.forEach(f);
+    }
+  }
+
+  private _set(key: K, value: V, getOld: boolean) {
+    if (this.contentSize + 1 >= this.threshold) {
+      this.growTable(this.table.length * 2);
+    }
+    const hash = this.computeHash(key);
+    const idx  = this.index(hash);
+    return this._set0(key, value, getOld, hash, idx);
+  }
+
+  private _setHash(key: K, value: V, hash: number, getOld: boolean) {
+    if (this.contentSize + 1 >= this.threshold) {
+      this.growTable(this.table.length * 2);
+    }
+    const idx = this.index(hash);
+    return this._set0(key, value, getOld, hash, idx);
+  }
+
+  private _set0(key: K, value: V, getOld: boolean, hash: number, idx: number): Maybe<V> {
+    let n = this.table[idx];
+    if (n === undefined) {
+      this.table[idx] = new Node(key, hash, value, undefined);
+    } else {
+      const old = n;
+      let prev: Node<K, V> | undefined = undefined;
+      while (n !== undefined && n.hash <= hash) {
+        if (n.hash === hash && this.config.equals_(key, n.key)) {
+          const old = n.value;
+          n.value   = value;
+          if (getOld) return Just(old);
+          else return Nothing();
+        }
+        prev = n;
+        n    = n.next;
+      }
+      if (prev === undefined) {
+        this.table[idx] = new Node(key, hash, value, old);
+      } else {
+        prev.next = new Node(key, hash, value, prev.next);
+      }
+    }
+    this.contentSize += 1;
+    return Nothing();
+  }
+
+  private _delete(key: K): Node<K, V> | undefined {
+    return this._deleteHash(key, this.computeHash(key));
+  }
+
+  private _deleteHash(key: K, hash: number): Node<K, V> | undefined {
+    const idx = this.index(hash);
+    const nd  = this.table[idx];
+    if (nd === undefined) {
+      return undefined;
+    } else if (nd.hash === hash && this.config.equals_(nd.key, key)) {
+      this.table[idx]   = nd.next;
+      this.contentSize -= 1;
+      return nd;
+    } else {
+      let prev = nd;
+      let next = nd.next;
+      while (next && next.hash <= hash) {
+        if (next.hash === hash && this.config.equals_(next.key, key)) {
+          prev.next         = next.next;
+          this.contentSize -= 1;
+          return next;
+        }
+        prev = next;
+        next = next.next;
+      }
+      return undefined;
+    }
+  }
+
+  private newThreshold(size: number) {
+    return Math.floor(size * this.loadFactor);
+  }
+
+  private computeHash(k: K): number {
+    return improveHash(this.config.hash(k));
+  }
+
+  private index(hash: number) {
+    return hash & (this.table.length - 1);
+  }
+
+  private findNode(key: K): Node<K, V> | undefined {
+    const hash = this.computeHash(key);
+    const n    = this.table[this.index(hash)];
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+  }
+
+  private growTable(newLen: number) {
+    assert(newLen >= 0, `New HashMap table size ${newLen}`);
+    let oldLen     = this.table.length;
+    this.threshold = this.newThreshold(newLen);
+    if (this.size === 0) {
+      this.table = new Array(newLen);
+    } else {
+      this.table    = copyOfArray(this.table, newLen);
+      const preLow  = new Node<K, V>(unsafeCoerce(undefined), 0, unsafeCoerce(undefined), undefined);
+      const preHigh = new Node<K, V>(unsafeCoerce(undefined), 0, unsafeCoerce(undefined), undefined);
+      while (oldLen < newLen) {
+        let i = 0;
+        while (i < oldLen) {
+          const old = this.table[i];
+          if (old !== undefined) {
+            preLow.next                   = undefined;
+            preHigh.next                  = undefined;
+            let lastLow                   = preLow;
+            let lastHigh                  = preHigh;
+            let n: Node<K, V> | undefined = old;
+            while (n) {
+              const next: Node<K, V> | undefined = n.next;
+              if ((n.hash & oldLen) === 0) {
+                lastLow.next = n;
+                lastLow      = n;
+              } else {
+                lastHigh.next = n;
+                lastHigh      = n;
+              }
+              n = next;
+            }
+            lastLow.next = undefined;
+            if (old !== preLow.next) {
+              this.table[i] = preLow.next;
+            }
+            if (preHigh.next !== undefined) {
+              this.table[i + oldLen] = preHigh.next;
+              lastHigh.next          = undefined;
+            }
+          }
+          i += 1;
+        }
+        oldLen *= 2;
+      }
+    }
+  }
+}
+
+class Node<K, V> {
+  constructor(public key: K, public hash: number, public value: V, public next: Node<K, V> | undefined) {}
+
+  findNode(k: K, h: number, equals: (x: K, y: K) => boolean): Node<K, V> | undefined {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let n: Node<K, V> | undefined = this;
+    while (n) {
+      if (h === n.hash && equals(k, n.key)) {
+        return n;
+      } else {
+        n = n.next;
+      }
+    }
+    return undefined;
+  }
+
+  forEach<U>(f: (k: K, v: V) => U): void {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let n: Node<K, V> | undefined = this;
+    while (n) {
+      f(n.key, n.value);
+      n = n.next;
+    }
+  }
+}
+
+export class HashMapIterator<K, V, A> implements Iterator<A> {
+  private node: Node<K, V> | undefined;
+  private i = 0;
+  private len: number;
+  private done = false;
+  constructor(private table: Array<Node<K, V> | undefined>, private extract: (nd: Node<K, V>) => A) {
+    this.len = table.length;
+  }
+
+  next(): IteratorResult<A> {
+    if (this.done) {
+      return this.return();
+    }
+    if (this.node === undefined) {
+      while (this.i < this.len) {
+        const n = this.table[this.i];
+        this.i += 1;
+        if (n != null) {
+          this.node = n;
+          break;
+        }
+      }
+      if (this.node === undefined) {
+        return this.return();
+      }
+    }
+    const value = this.extract(this.node);
+    this.node   = this.node.next;
+    return { done: false, value };
+  }
+
+  return(value?: unknown): IteratorReturnResult<unknown> {
+    if (!this.done) {
+      this.done = true;
+    }
+    return { done: true, value };
+  }
+}

package/_src/collection/mutable/HashSet.ts

@@ -0,0 +1,254 @@
+/*
+ * This file contains software ported from:
+ *
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the doc/LICENSE.md file in the root of this source tree
+ * for more information regarding copyright ownership
+ */
+
+import { copyOfArray, improveHash, tableSizeFor } from "@fncts/base/collection/mutable/internal";
+import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { assert } from "@fncts/base/util/assert";
+
+const DEFAULT_INITIAL_CAPACITY = 16;
+const DEFAULT_LOAD_FACTOR      = 0.75;
+
+/**
+ * @tsplus type fncts.MutableHashSet
+ * @tsplus companion fncts.MutableHashSetOps
+ */
+export class HashSet<A> implements Iterable<A> {
+  constructor(
+    private initialCapacity: number,
+    private loadFactor: number,
+    private config: HashEq<A> = HashEq.StructuralStrict,
+  ) {
+    this.table = new Array<Node<A> | undefined>(tableSizeFor(this.initialCapacity));
+
+    this.threshold = this.newThreshold(this.table.length);
+  }
+
+  [Symbol.iterator](): Iterator<A> {
+    return new HashSetIterator(this.table, (nd) => nd.key);
+  }
+
+  private table: Array<Node<A> | undefined>;
+
+  private threshold: number;
+
+  private contentSize = 0;
+
+  static empty<A>(config?: HashEq<A>) {
+    return new HashSet(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, config);
+  }
+
+  get size(): number {
+    return this.contentSize;
+  }
+
+  has(key: A): boolean {
+    return this.findNode(key) !== undefined;
+  }
+
+  add(elem: A): boolean {
+    this.contentSize + 1 >= this.threshold && this.growTable(this.table.length * 2);
+    return this.addHash(elem, this.computeHash(elem));
+  }
+
+  remove(elem: A): boolean {
+    return this.removeHash(elem, this.computeHash(elem));
+  }
+
+  forEach<U>(f: (elem: A) => U): void {
+    for (let i = 0; i < this.table.length; i++) {
+      const n = this.table[i];
+      if (n) n.forEach(f);
+    }
+  }
+
+  private addHash(elem: A, hash: number): boolean {
+    const idx = this.index(hash);
+    let n     = this.table[idx];
+    if (n === undefined) {
+      this.table[idx] = new Node(elem, hash, undefined);
+    } else {
+      const old                     = n;
+      let prev: Node<A> | undefined = undefined;
+      while (n !== undefined && n.hash <= hash) {
+        if (n.hash === hash && this.config.equals_(elem, n.key)) {
+          return false;
+        }
+        prev = n;
+        n    = n.next;
+      }
+      if (prev === undefined) {
+        this.table[idx] = new Node(elem, hash, old);
+      } else {
+        prev.next = new Node(elem, hash, prev.next);
+      }
+    }
+    this.contentSize += 1;
+    return true;
+  }
+
+  private removeHash(elem: A, hash: number): boolean {
+    const idx = this.index(hash);
+    const n   = this.table[idx];
+    if (n === undefined) {
+      return false;
+    } else if (n.hash === hash && this.config.equals_(n.key, elem)) {
+      this.table[idx]   = n.next;
+      this.contentSize -= 1;
+      return true;
+    } else {
+      let prev = n;
+      let next = n.next;
+      while (next && next.hash <= hash) {
+        if (next.hash === hash && this.config.equals_(next.key, elem)) {
+          prev.next         = next.next;
+          this.contentSize -= 1;
+          return true;
+        }
+        prev = next;
+        next = next.next;
+      }
+      return false;
+    }
+  }
+
+  private newThreshold(size: number) {
+    return Math.floor(size * this.loadFactor);
+  }
+
+  private computeHash(k: A): number {
+    return improveHash(this.config.hash(k));
+  }
+
+  private index(hash: number) {
+    return hash & (this.table.length - 1);
+  }
+
+  private findNode(key: A): Node<A> | undefined {
+    const hash = this.computeHash(key);
+    const n    = this.table[this.index(hash)];
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+  }
+
+  private growTable(newLen: number) {
+    assert(newLen >= 0, `New HashSet table size ${newLen}`);
+    let oldLen     = this.table.length;
+    this.threshold = this.newThreshold(newLen);
+    if (this.size === 0) {
+      this.table = new Array(newLen);
+    } else {
+      this.table    = copyOfArray(this.table, newLen);
+      const preLow  = new Node<A>(unsafeCoerce(undefined), 0, undefined);
+      const preHigh = new Node<A>(unsafeCoerce(undefined), 0, undefined);
+      while (oldLen < newLen) {
+        let i = 0;
+        while (i < oldLen) {
+          const old = this.table[i];
+          if (old !== undefined) {
+            preLow.next                = undefined;
+            preHigh.next               = undefined;
+            let lastLow                = preLow;
+            let lastHigh               = preHigh;
+            let n: Node<A> | undefined = old;
+            while (n) {
+              const next: Node<A> | undefined = n.next;
+              if ((n.hash & oldLen) === 0) {
+                lastLow.next = n;
+                lastLow      = n;
+              } else {
+                lastHigh.next = n;
+                lastHigh      = n;
+              }
+              n = next;
+            }
+            lastLow.next = undefined;
+            if (old !== preLow.next) {
+              this.table[i] = preLow.next;
+            }
+            if (preHigh.next !== undefined) {
+              this.table[i + oldLen] = preHigh.next;
+              lastHigh.next          = undefined;
+            }
+          }
+          i += 1;
+        }
+        oldLen *= 2;
+      }
+    }
+  }
+}
+
+class Node<K> {
+  constructor(public key: K, public hash: number, public next: Node<K> | undefined) {}
+
+  findNode(k: K, h: number, equals: (x: K, y: K) => boolean): Node<K> | undefined {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let n: Node<K> | undefined = this;
+    while (n) {
+      if (h === n.hash && equals(k, n.key)) {
+        return n;
+      } else {
+        n = n.next;
+      }
+    }
+    return undefined;
+  }
+
+  forEach<U>(f: (k: K) => U): void {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let n: Node<K> | undefined = this;
+    while (n) {
+      f(n.key);
+      n = n.next;
+    }
+  }
+}
+
+export class HashSetIterator<V, A> implements Iterator<A> {
+  private node: Node<V> | undefined;
+  private len: number;
+  private i    = 0;
+  private done = false;
+  constructor(private table: Array<Node<V> | undefined>, private extract: (nd: Node<V>) => A) {
+    this.len = table.length;
+  }
+
+  next(): IteratorResult<A> {
+    if (this.done) {
+      return this.return();
+    }
+    if (this.node === undefined) {
+      while (this.i < this.len) {
+        const n = this.table[this.i];
+        this.i += 1;
+        if (n != null) {
+          this.node = n;
+          break;
+        }
+      }
+      if (this.node === undefined) {
+        return this.return();
+      }
+    }
+    const value = this.extract(this.node);
+    this.node   = this.node.next;
+    return { done: false, value };
+  }
+
+  return(value?: unknown): IteratorReturnResult<unknown> {
+    if (!this.done) {
+      this.done = true;
+    }
+    return { done: true, value };
+  }
+}

package/_src/collection/mutable/ListBuffer.ts

@@ -0,0 +1,123 @@
+/*
+ * This file contains software ported from:
+ *
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the doc/LICENSE.md file in the root of this source tree
+ * for more information regarding copyright ownership
+ */
+
+import { _Nil } from "@fncts/base/collection/immutable/List/definition";
+
+export class ListBuffer<A> implements Iterable<A> {
+  private first: List<A>             = _Nil;
+  private last0: Cons<A> | undefined = undefined;
+  private len = 0;
+
+  [Symbol.iterator](): Iterator<A> {
+    return this.first[Symbol.iterator]();
+  }
+
+  get length(): number {
+    return this.len;
+  }
+
+  get isEmpty(): boolean {
+    return this.len === 0;
+  }
+
+  get unsafeHead(): A {
+    if (this.isEmpty) {
+      throw new NoSuchElementError("head on empty ListBuffer");
+    }
+    return (this.first as Cons<A>).head;
+  }
+
+  get unsafeTail(): List<A> {
+    if (this.isEmpty) {
+      throw new NoSuchElementError("tail on empty ListBuffer");
+    }
+    return (this.first as Cons<A>).tail;
+  }
+
+  append(elem: A): this {
+    const last1 = new Cons(elem, _Nil);
+    if (this.len === 0) {
+      this.first = last1;
+    } else {
+      this.last0!.tail = last1;
+    }
+    this.last0 = last1;
+    this.len  += 1;
+    return this;
+  }
+
+  prepend(elem: A): this {
+    this.insert(0, elem);
+    return this;
+  }
+
+  unprepend(): A {
+    if (this.isEmpty) {
+      throw new NoSuchElementError("unprepend on empty ListBuffer");
+    }
+    const h    = (this.first as Cons<A>).head;
+    this.first = (this.first as Cons<A>).tail;
+    this.len  -= 1;
+    return h;
+  }
+
+  get toList(): List<A> {
+    return this.first;
+  }
+
+  insert(idx: number, elem: A): this {
+    if (idx < 0 || idx > this.len) {
+      throw new IndexOutOfBoundsError(`${idx} is out of bounds (min 0, max ${this.len - 1})`);
+    }
+    if (idx === this.len) {
+      this.append(elem);
+    } else {
+      const p  = this.locate(idx);
+      const nx = new Cons(elem, this.getNext(p));
+      if (p === undefined) {
+        this.first = nx;
+      } else {
+        (p as Cons<A>).tail = nx;
+      }
+      this.len += 1;
+    }
+    return this;
+  }
+
+  foldl<B>(b: B, f: (b: B, a: A) => B): B {
+    return this.first.foldLeft(b, f);
+  }
+
+  private getNext(p: List<A> | undefined): List<A> {
+    if (p === undefined) {
+      return this.first;
+    } else {
+      return p.unsafeTail;
+    }
+  }
+
+  private locate(i: number): List<A> | undefined {
+    if (i === 0) {
+      return undefined;
+    } else if (i === this.len) {
+      return this.last0;
+    } else {
+      let p = this.first;
+      for (let j = i - 1; j > 0; j--) {
+        p = p.unsafeTail;
+      }
+      return p;
+    }
+  }
+}