atomic-fns 0.3.5 → 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 = any> {
-  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.ts

@@ -1,338 +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.
- * @template T
- */
-export class Deque<T = any> extends Sequence<T> {
-  items: T[]
-  start: number = 0
-  count: number = 0
-  capacity: number
-  ArrayConstructor: any
-
-  /**
-   * Creates a new `Deque` instance of a fixed size.
-   * @param {Array} [arrType = []] The initial elements or array type to use (accepts any kind of typed array).
-   * @param {number} [capacity=1024] The fixed size of the deque. Defaults to `1024`.
-   */
-  constructor(arrType = [] as T[], capacity = 1024) {
-    super()
-    if (typeof capacity !== 'number' || capacity <= 0)
-      throw new ValueError(`Deque capacity should be a positive integer.`)
-
-    this.ArrayConstructor = arrType.constructor
-    this.capacity = capacity
-    this.items = new this.ArrayConstructor(arrType.length || this.capacity)
-    this.clear()
-
-    if (arrType.length) {
-      for (const item of arrType) {
-        this.append(item)
-      }
-    }
-  }
-
-  /** Returns the total number of elements in the deque. */
-  get size() {
-    return this.count
-  }
-
-  /**
-   * Method used to clear the structure.
-   */
-  clear() {
-    // Properties
-    this.start = 0
-    this.count = 0
-  }
-
-  /**
-   * Alias of {@link Deque.append}
-   * @param {T} item Item to append.
-   * @returns {number} Returns the new size of the deque.
-   */
-  add(item) {
-    return this.append(item)
-  }
-
-  /**
-   * Appends a new element to the end of the deque.
-   * @param {T} item Item to append.
-   * @returns {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
-  }
-
-  /**
-   * Appends a new element to the beginning of the deque.
-   * @param {T} item Item to prepend.
-   * @returns {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
-  }
-
-  /**
-   * Removes and returns the element at the end of the deque.
-   * @returns {?T} 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}
-   * @returns {?T} Returns the popped item.
-   */
-  remove() {
-    return this.pop()
-  }
-
-  /**
-   * Removes and returns the element at the beginning of the deque.
-   * @returns {?T} Returns the removed deque element.
-   */
-  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]
-  }
-
-  /**
-   * Returns the element at the beginning of the deque.
-   * @returns {?T} The element if exists
-   */
-  first() {
-    if (this.count === 0) return
-
-    return this.items[this.start]
-  }
-
-  /**
-   * Returns the element at a specified index position in the deque.
-   * @param {number} index The given index
-   * @returns {?T} The element if exists
-   */
-  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 element at a given `index`.
-   * @param {number} index The given 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
-  }
-
-  /**
-   * Check if a given element is in the deque.
-   * @param {T} x The value to find
-   * @returns {boolean} `true` if the value is found
-   */
-  contains(x) {
-    for (const value of this.values()) {
-      if (eq(x, value)) return true
-    }
-    return false
-  }
-
-  /**
-   * Returns the first element that matches the `iteratee` function.
-   * @param {Iteratee<T>} iteratee A function that will be invoked per element
-   * @returns {?T} The element if exists
-   */
-  find(iteratee: Iteratee<T>) {
-    for (const [key, value] of this.entries()) {
-      if (iteratee(value, key, this)) return value
-    }
-  }
-
-  /**
-   * Calls `iteratee` function for every element in the deque.
-   * @param {Iteratee<T>} iteratee A function that will be invoked per element
-   */
-  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
-    }
-  }
-
-  /**
-   * Returns a new array with all the elements in reverse order.
-   * @returns {Array<T>} The elements reversed
-   */
-  reversed() {
-    return this.toArray().reverse()
-  }
-
-  /**
-   * Returns a new array with all the elements in the order they were added to the deque.
-   * @returns {Array<T>} The elements array
-   */
-  toArray() {
-    // Optimization
-    const offset = this.start + this.count
-
-    if (offset < this.capacity) return this.items.slice(this.start, offset)
-
-    const array = new this.ArrayConstructor(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
-  }
-
-  /**
-   * Returns an iterator over the deque's values.
-   * @returns {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
-      }
-    })
-  }
-
-  /**
-   * Alias of {@link Deque.values}. Returns iterator of values.
-   */
-  keys() {
-    return this.values()
-  }
-
-  /**
-   * Creates an iterator of `[index, value]` pairs for all elements in the deque.
-   * @returns {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()
-  }
-
-  // This is just for debugging in nodejs
-  inspect() {
-    const array = this.toArray()
-
-    array.type = this.ArrayConstructor.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)
-  }
-}