atomic-fns 0.3.4 → 0.4.2

package/core/collections/abc.ts

@@ -1,176 +0,0 @@
-/**
- * A container type that provides contains().
- *
- *
- * @interface Container
- */
-export interface Container {
-  contains: (x) => boolean
-}
-
-/**
- * Implements an equality check between two values.
- * @interface Ordered
- */
-export interface Equals {
-  eq: (other) => boolean
-}
-
-/**
- * Implements an iterable that allows comparing two elements to determine ordering.
- * @interface Ordered
- */
-export interface Comparable {
-  compare: (other) => number
-}
-
-/**
- * Implements an iterable that allows sorting elements.
- * @interface Ordered
- */
-export interface Ordered<T> {
-  lt: (other) => boolean
-}
-
-/**
- * Implements an iterable that allows backward iteration.
- * @interface Reversible
- */
-export interface Reversible<T = unknown> {
-  reversed: () => Iterable<T>
-}
-
-/**
- * A `Collection` is an iterable {@link Container} type.
- * This is an abstract base class for user-defined collection types.
- *
- *
- * @abstract
- * @class Collection
- * @implements {Container}
- */
-export abstract class Collection implements Container {
-  /**
-   * Adds a new item to the collection.
-   * @param item - The item to add to the collection.
-   */
-  abstract add(item): any
-
-  /**
-   * Checks if item is present in the collection.
-   * @param item - The item to search for in the collection.
-   * @returns `true` when the element is found, else `false`
-   */
-  abstract contains(item): boolean
-
-  /**
-   * Remove all items from the collection
-   */
-  abstract clear()
-
-  /**
-   * Returns the total number of elements in the collection.
-   */
-  abstract get size(): number
-
-  get length() {
-    return this.size
-  }
-
-  /**
-   * Check if there are no items.
-   * @returns {boolean} `true` if is empty.
-   */
-  empty() {
-    return !this.size
-  }
-}
-
-/**
- * A sequence is an iterable {@link Collection} type with efficient index-based access.
- * @abstract
- * @class Sequence
- * @extends {Collection}
- * @template V
- */
-export abstract class Sequence<V = any, K = any> extends Collection {
-  /**
-   * Return the item at the given key or index
-   * @param {K} key
-   * @memberof Sequence
-   */
-  abstract get(key: K)
-
-  /**
-   * Set a new value at the given key or index
-   *
-   * @param {K} key
-   * @param {V} value
-   * @memberof Sequence
-   */
-  abstract set(key: K, value: V)
-
-  /**
-   * Adds a new item to the end of the sequence. Alias of {@link Collection.add}.
-   *
-   * @param {V} x
-   * @memberof Sequence
-   */
-  abstract append(x: V | Iterable<V>)
-
-  /**
-   * Remove a given value from the collection if exists.
-   * @returns the value that was removed or `undefined`.
-   */
-  abstract remove(x: V)
-
-  /**
-   * Returns an iterator of all the `keys` in order.
-   */
-  abstract keys(): Iterable<K>
-  /**
-   * Returns an iterator of all the `values` in order.
-   */
-  abstract values(): Iterable<V>
-
-  /**
-   * Returns an iterator of all the `[key, value]` pairs in order.
-   */
-  abstract entries(): Iterable<[K, V]>
-}
-
-/**
- * A mapping is a {@link Collection} indexed by keys that may have associated values.
- * @abstract
- * @class Mapping
- * @extends {Collection}
- * @template K, V
- */
-export abstract class Mapping<K, V> extends Collection {
-  /**
-   * Returns the value for the given key, or return `defaults` if not found.
-   * @param {K} key
-   * @param {*} [defaults]
-   */
-  abstract get(key: K, defaults?): V | undefined
-
-  /**
-   * Sets the value for the given key.
-   * @param {K} key
-   */
-  abstract set(key: K, value: V)
-
-  /**
-   * Returns an iterator of all the `keys` in the map.
-   */
-  abstract keys(): Iterable<K>
-  /**
-   * Returns an iterator of all the `values` in the map.
-   */
-  abstract values(): Iterable<V>
-
-  /**
-   * Returns an iterator of all the `[key, value]` pairs in the map.
-   */
-  abstract entries(): Iterable<[K, V]>
-}

package/core/collections/deque.d.ts

@@ -1,110 +0,0 @@
-import { Iteratee } from '../globals/index.js';
-import { Sequence } from './abc.js';
-/**
- * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
- */
-export declare class Deque<T> extends Sequence<T> {
-    items: T[];
-    start: number;
-    count: number;
-    capacity: number;
-    ArrayClass: any;
-    constructor(ArrayClass?: T[], capacity?: number);
-    get size(): number;
-    /**
-     * Method used to clear the structure.
-     *
-     * @return {undefined}
-     */
-    clear(): void;
-    /**
-     * Alias of {@link Deque.append}
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
-     */
-    add(item: any): number;
-    /**
-     * Method used to append a value to the deque.
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
-     */
-    append(item: any): number;
-    /**
-     * Method used to prepend a value to the deque.
-     *
-     * @param  {any}    item - Item to prepend.
-     * @return {number}      - Returns the new size of the deque.
-     */
-    appendleft(item: any): number;
-    /**
-     * Method used to pop the deque.
-     *
-     * @return {any} - Returns the popped item.
-     */
-    pop(): T | undefined;
-    /**
-     * Alias of {@link Deque.pop}
-     */
-    remove(): T | undefined;
-    /**
-     * Method used to shift the deque.
-     *
-     * @return {any} - Returns the shifted item.
-     */
-    popleft(): T | undefined;
-    /**
-     * Method used to peek the first value of the deque.
-     *
-     * @return {any}
-     */
-    first(): T | undefined;
-    /**
-     * Method used to get the desired value of the deque.
-     *
-     * @param  {number} index
-     * @return {any}
-     */
-    get(index: any): T | undefined;
-    /**
-     * Update the value at a given `index`.
-     * @param index The given index
-     * @param value The new value to set at `index`.
-     */
-    set(index: number, value: T): void;
-    contains(x: any): boolean;
-    find(iteratee: Iteratee<T>): T | undefined;
-    /**
-     * Method used to iterate over the deque.
-     *
-     * @param  {function}  iteratee - Function to call for each item.
-     * @param  {object}    scope    - Optional scope.
-     * @return {undefined}
-     */
-    forEach(iteratee: any): void;
-    reversed(): any;
-    /**
-     * Method used to convert the deque to a JavaScript array.
-     *
-     * @return {array}
-     */
-    toArray(): any;
-    /**
-     * Method used to create an iterator over the deque's values.
-     *
-     * @return {Iterator}
-     */
-    values(): Iterable<T>;
-    keys(): Iterable<T>;
-    /**
-     * Method used to create an iterator over the deque's entries.
-     *
-     * @return {Iterator}
-     */
-    entries(): Iterator<[number, T], any, undefined> & Iterable<[number, T]>;
-    [Symbol.iterator](): Iterable<T>;
-    inspect(): any;
-}

package/core/collections/deque.ts

@@ -1,329 +0,0 @@
-import { Iteratee, KeyError, ValueError } from '../globals/index.js'
-import { IterableIterator } from '../itertools/index.js'
-import { eq } from '../operators/index.js'
-import { Sequence } from './abc.js'
-
-/**
- * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
- */
-export class Deque<T> extends Sequence<T> {
-  items: T[]
-  start: number = 0
-  count: number = 0
-  capacity: number
-  ArrayClass: any
-
-  constructor(ArrayClass = [] as T[], capacity = 1024) {
-    super()
-    if (typeof capacity !== 'number' || capacity <= 0)
-      throw new ValueError(`Deque capacity should be a positive integer.`)
-
-    this.ArrayClass = ArrayClass.constructor
-    this.capacity = capacity
-    this.items = new this.ArrayClass(ArrayClass.length || this.capacity)
-    this.clear()
-    if (ArrayClass.length) {
-      for (const item of ArrayClass) {
-        this.append(item)
-      }
-    }
-  }
-
-  get size() {
-    return this.count
-  }
-
-  /**
-   * Method used to clear the structure.
-   *
-   * @return {undefined}
-   */
-  clear() {
-    // Properties
-    this.start = 0
-    this.count = 0
-  }
-
-  /**
-   * Alias of {@link Deque.append}
-   *
-   * @param  {any}    item - Item to append.
-   * @return {number}      - Returns the new size of the deque.
-   */
-  add(item) {
-    return this.append(item)
-  }
-
-  /**
-   * Method used to append a value to the deque.
-   *
-   * @param  {any}    item - Item to append.
-   * @return {number}      - Returns the new size of the deque.
-   */
-  append(item) {
-    if (this.count === this.capacity) this.popleft()
-
-    const index = (this.start + this.count) % this.capacity
-
-    this.items[index] = item
-
-    return ++this.count
-  }
-
-  /**
-   * Method used to prepend a value to the deque.
-   *
-   * @param  {any}    item - Item to prepend.
-   * @return {number}      - Returns the new size of the deque.
-   */
-  appendleft(item) {
-    if (this.count === this.capacity) this.pop()
-
-    let index = this.start - 1
-
-    if (this.start === 0) index = this.capacity - 1
-
-    this.items[index] = item
-    this.start = index
-
-    return ++this.count
-  }
-
-  /**
-   * Method used to pop the deque.
-   *
-   * @return {any} - Returns the popped item.
-   */
-  pop() {
-    if (this.count === 0) return
-
-    const index = (this.start + this.count - 1) % this.capacity
-
-    this.count--
-
-    return this.items[index]
-  }
-
-  /**
-   * Alias of {@link Deque.pop}
-   */
-  remove() {
-    return this.pop()
-  }
-
-  /**
-   * Method used to shift the deque.
-   *
-   * @return {any} - Returns the shifted item.
-   */
-  popleft() {
-    if (this.count === 0) return
-
-    const index = this.start
-
-    this.count--
-    this.start++
-
-    if (this.start === this.capacity) this.start = 0
-
-    return this.items[index]
-  }
-
-  /**
-   * Method used to peek the first value of the deque.
-   *
-   * @return {any}
-   */
-  first() {
-    if (this.count === 0) return
-
-    return this.items[this.start]
-  }
-
-  /**
-   * Method used to get the desired value of the deque.
-   *
-   * @param  {number} index
-   * @return {any}
-   */
-  get(index) {
-    if (this.count === 0) return
-
-    index = this.start + index
-    if (index < 0) index += this.count
-
-    if (index > this.capacity) index -= this.capacity
-
-    return this.items[index]
-  }
-
-  /**
-   * Update the value at a given `index`.
-   * @param index The given index
-   * @param value The new value to set at `index`.
-   */
-  set(index: number, value: T) {
-    if (index < 0) index += this.count
-    if (index > this.count) throw new KeyError(`Invalid index: ${index} not in Deque.`)
-    this.items[index] = value
-  }
-
-  contains(x) {
-    for (const value of this.values()) {
-      if (eq(x, value)) return true
-    }
-    return false
-  }
-
-  find(iteratee: Iteratee<T>) {
-    for (const [key, value] of this.entries()) {
-      if (iteratee(value, key, this)) return value
-    }
-  }
-
-  /**
-   * Method used to iterate over the deque.
-   *
-   * @param  {function}  iteratee - Function to call for each item.
-   * @param  {object}    scope    - Optional scope.
-   * @return {undefined}
-   */
-  forEach(iteratee) {
-    const c = this.capacity
-    const l = this.count
-    let i = this.start
-    let j = 0
-
-    while (j < l) {
-      iteratee(this.items[i], j, this)
-      i++
-      j++
-
-      if (i === c) i = 0
-    }
-  }
-
-  reversed() {
-    return this.toArray().reverse()
-  }
-
-  /**
-   * Method used to convert the deque to a JavaScript array.
-   *
-   * @return {array}
-   */
-  toArray() {
-    // Optimization
-    const offset = this.start + this.count
-
-    if (offset < this.capacity) return this.items.slice(this.start, offset)
-
-    const array = new this.ArrayClass(this.count)
-    const c = this.capacity
-    const l = this.count
-    let i = this.start
-    let j = 0
-
-    while (j < l) {
-      array[j] = this.items[i]
-      i++
-      j++
-
-      if (i === c) i = 0
-    }
-
-    return array
-  }
-
-  /**
-   * Method used to create an iterator over the deque's values.
-   *
-   * @return {Iterator}
-   */
-  values(): Iterable<T> {
-    const items = this.items
-    const c = this.capacity
-    const l = this.count
-    let i = this.start
-    let j = 0
-
-    return IterableIterator(() => {
-      if (j >= l)
-        return {
-          done: true
-        }
-
-      const value = items[i]
-
-      i++
-      j++
-
-      if (i === c) i = 0
-
-      return {
-        value,
-        done: false
-      }
-    })
-  }
-
-  keys() {
-    return this.values()
-  }
-
-  /**
-   * Method used to create an iterator over the deque's entries.
-   *
-   * @return {Iterator}
-   */
-  entries() {
-    const items = this.items
-    const c = this.capacity
-    const l = this.count
-    let i = this.start
-    let j = 0
-
-    return IterableIterator<[number, T]>(() => {
-      if (j >= l)
-        return {
-          done: true
-        }
-
-      const value = items[i]
-
-      i++
-
-      if (i === c) i = 0
-
-      return {
-        value: [j++, value],
-        done: false
-      }
-    })
-  }
-
-  [Symbol.iterator]() {
-    return this.values()
-  }
-
-  [Symbol.for('nodejs.util.inspect.custom')]() {
-    return this.inspect()
-  }
-
-  inspect() {
-    const array = this.toArray()
-
-    array.type = this.ArrayClass.name
-    array.capacity = this.capacity
-
-    // Trick so that node displays the name of the constructor
-    Object.defineProperty(array, 'constructor', {
-      value: Deque,
-      enumerable: false
-    })
-
-    return array
-  }
-}

package/core/collections/frozenset.ts

@@ -1,37 +0,0 @@
-/**
- * Returns a new immutable Set object with elements from `iterable`. Its contents cannot be altered after it's created.
- *
- *
- * @class FrozenSet
- * @extends {Set<T>}
- * @template T
- */
-export class FrozenSet<T = any> extends Set<T> {
-  constructor(iterable: Iterable<T>) {
-    super(iterable)
-    return this.freeze()
-  }
-
-  /** @private */
-  add() {
-    throw TypeError('FrozenSet cannot be modified.')
-    return this // eslint-disable-line
-  }
-
-  /** @private */
-  delete() {
-    throw TypeError('FrozenSet cannot be modified.')
-    return false // eslint-disable-line
-  }
-
-  /** @private */
-  clear() {
-    throw TypeError('FrozenSet cannot be modified.')
-    return this // eslint-disable-line
-  }
-
-  /** @private */
-  freeze() {
-    return Object.freeze(this)
-  }
-}