effect 2.0.0-next.44 → 2.0.0-next.46

package/src/MutableHashMap.ts

@@ -0,0 +1,187 @@
+/**
+ * @since 2.0.0
+ */
+import * as Dual from "./Function"
+import * as HashMap from "./HashMap"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import * as MutableRef from "./MutableRef"
+import * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+
+const TypeId: unique symbol = Symbol.for("effect/MutableHashMap") as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MutableHashMap<K, V> extends Iterable<readonly [K, V]>, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+
+  /** @internal */
+  readonly backingMap: MutableRef.MutableRef<HashMap.HashMap<K, V>>
+}
+
+const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "backingMap"> = {
+  [TypeId]: TypeId,
+  [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<readonly [unknown, unknown]> {
+    return this.backingMap.current[Symbol.iterator]()
+  },
+  toString() {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "MutableHashMap",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const fromHashMap = <K, V>(backingMap: HashMap.HashMap<K, V>): MutableHashMap<K, V> => {
+  const map = Object.create(MutableHashMapProto)
+  map.backingMap = MutableRef.make(backingMap)
+  return map
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <K = never, V = never>(): MutableHashMap<K, V> => fromHashMap<K, V>(HashMap.empty())
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Entries extends Array<readonly [any, any]>>(
+  ...entries: Entries
+) => MutableHashMap<
+  Entries[number] extends readonly [infer K, any] ? K : never,
+  Entries[number] extends readonly [any, infer V] ? V : never
+> = (...entries) => fromIterable(entries)
+
+/**
+ * @since 2.0.0
+ * @category conversions
+ */
+export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): MutableHashMap<K, V> =>
+  fromHashMap(HashMap.fromIterable(entries))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const get: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>
+  <K, V>(self: MutableHashMap<K, V>, key: K): Option.Option<V>
+} = Dual.dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => Option.Option<V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => Option.Option<V>
+>(2, <K, V>(self: MutableHashMap<K, V>, key: K) => HashMap.get(self.backingMap.current, key))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean
+  <K, V>(self: MutableHashMap<K, V>, key: K): boolean
+} = Dual.dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => boolean,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => boolean
+>(2, (self, key) => Option.isSome(get(self, key)))
+
+/**
+ * Updates the value of the specified key within the `MutableHashMap` if it exists.
+ *
+ * @since 2.0.0
+ */
+export const modify: {
+  <K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V): MutableHashMap<K, V>
+} = Dual.dual<
+  <K, V>(key: K, f: (v: V) => V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => MutableHashMap<K, V>
+>(
+  3,
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => {
+    MutableRef.update(self.backingMap, HashMap.modify(key, f))
+    return self
+  }
+)
+
+/**
+ * Set or remove the specified key in the `MutableHashMap` using the specified
+ * update function.
+ *
+ * @since 2.0.0
+ */
+export const modifyAt: {
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): MutableHashMap<K, V>
+} = Dual.dual<
+  <K, V>(
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(
+    self: MutableHashMap<K, V>,
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ) => MutableHashMap<K, V>
+>(3, (self, key, f) => {
+  const result = f(get(self, key))
+  if (Option.isSome(result)) {
+    set(self, key, result.value)
+  } else {
+    remove(self, key)
+  }
+  return self
+})
+
+/**
+ * @since 2.0.0
+ */
+export const remove: {
+  <K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K): MutableHashMap<K, V>
+} = Dual.dual<
+  <K>(key: K) => <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K) => MutableHashMap<K, V>
+>(2, <K, V>(self: MutableHashMap<K, V>, key: K) => {
+  MutableRef.update(self.backingMap, HashMap.remove(key))
+  return self
+})
+
+/**
+ * @since 2.0.0
+ */
+export const set: {
+  <K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
+  <K, V>(self: MutableHashMap<K, V>, key: K, value: V): MutableHashMap<K, V>
+} = Dual.dual<
+  <K, V>(key: K, value: V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
+  <K, V>(self: MutableHashMap<K, V>, key: K, value: V) => MutableHashMap<K, V>
+>(3, <K, V>(self: MutableHashMap<K, V>, key: K, value: V) => {
+  MutableRef.update(self.backingMap, HashMap.set(key, value))
+  return self
+})
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const size = <K, V>(self: MutableHashMap<K, V>): number => HashMap.size(MutableRef.get(self.backingMap))

package/src/MutableHashSet.ts

@@ -0,0 +1,118 @@
+/**
+ * @since 2.0.0
+ */
+import * as Dual from "./Function"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import * as MutableHashMap from "./MutableHashMap"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+
+const TypeId: unique symbol = Symbol.for("effect/MutableHashSet") as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MutableHashSet<V> extends Iterable<V>, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+
+  /** @internal */
+  readonly keyMap: MutableHashMap.MutableHashMap<V, boolean>
+}
+
+const MutableHashSetProto: Omit<MutableHashSet<unknown>, "keyMap"> = {
+  [TypeId]: TypeId,
+  [Symbol.iterator](this: MutableHashSet<unknown>): Iterator<unknown> {
+    return Array.from(this.keyMap).map(([_]) => _)[Symbol.iterator]()
+  },
+  toString() {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "MutableHashSet",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const fromHashMap = <V>(keyMap: MutableHashMap.MutableHashMap<V, boolean>): MutableHashSet<V> => {
+  const set = Object.create(MutableHashSetProto)
+  set.keyMap = keyMap
+  return set
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <K = never>(): MutableHashSet<K> => fromHashMap(MutableHashMap.empty())
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = <K = never>(keys: Iterable<K>): MutableHashSet<K> =>
+  fromHashMap(MutableHashMap.fromIterable(Array.from(keys).map((k) => [k, true])))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <Keys extends ReadonlyArray<unknown>>(
+  ...keys: Keys
+): MutableHashSet<Keys[number]> => fromIterable(keys)
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const add: {
+  <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
+  <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>
+} = Dual.dual<
+  <V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>,
+  <V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>
+>(2, (self, key) => (MutableHashMap.set(self.keyMap, key, true), self))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <V>(key: V): (self: MutableHashSet<V>) => boolean
+  <V>(self: MutableHashSet<V>, key: V): boolean
+} = Dual.dual<
+  <V>(key: V) => (self: MutableHashSet<V>) => boolean,
+  <V>(self: MutableHashSet<V>, key: V) => boolean
+>(2, (self, key) => MutableHashMap.has(self.keyMap, key))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const remove: {
+  <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
+  <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>
+} = Dual.dual<
+  <V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>,
+  <V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>
+>(2, (self, key) => (MutableHashMap.remove(self.keyMap, key), self))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const size = <V>(self: MutableHashSet<V>): number => MutableHashMap.size(self.keyMap)

package/src/MutableList.ts

@@ -0,0 +1,289 @@
+/**
+ * @since 2.0.0
+ */
+import * as Dual from "./Function"
+import { NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import type { Inspectable } from "./Inspectable"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+
+const TypeId: unique symbol = Symbol.for("effect/MutableList") as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface MutableList<A> extends Iterable<A>, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+
+  /** @internal */
+  head: LinkedListNode<A> | undefined
+  /** @internal */
+  tail: LinkedListNode<A> | undefined
+}
+
+const MutableListProto: Omit<MutableList<unknown>, "head" | "tail"> = {
+  [TypeId]: TypeId,
+  [Symbol.iterator](this: MutableList<unknown>): Iterator<unknown> {
+    let done = false
+    let head: LinkedListNode<unknown> | undefined = this.head
+    return {
+      next() {
+        if (done) {
+          return this.return!()
+        }
+        if (head == null) {
+          done = true
+          return this.return!()
+        }
+        const value = head.value
+        head = head.next
+        return { done, value }
+      },
+      return(value?: unknown) {
+        if (!done) {
+          done = true
+        }
+        return { done: true, value }
+      }
+    }
+  },
+  toString() {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "MutableList",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+interface MutableListImpl<A> extends MutableList<A> {
+  _length: number
+}
+
+/** @internal */
+class LinkedListNode<T> {
+  removed = false
+  prev: LinkedListNode<T> | undefined = undefined
+  next: LinkedListNode<T> | undefined = undefined
+  constructor(readonly value: T) {}
+}
+
+/**
+ * Creates an empty `MutableList`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <A>(): MutableList<A> => {
+  const list = Object.create(MutableListProto)
+  list.head = undefined
+  list.tail = undefined
+  list._length = 0
+  return list
+}
+
+/**
+ * Creates a new `MutableList` from an `Iterable`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = <A>(iterable: Iterable<A>): MutableList<A> => {
+  const list = empty<A>()
+  for (const element of iterable) {
+    append(list, element)
+  }
+  return list
+}
+
+/**
+ * Creates a new `MutableList` from the specified elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A>(...elements: ReadonlyArray<A>): MutableList<A> => fromIterable(elements)
+
+/**
+ * Returns `true` if the list contains zero elements, `false`, otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty = <A>(self: MutableList<A>): boolean => length(self) === 0
+
+/**
+ * Returns the length of the list.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const length = <A>(self: MutableList<A>): number => (self as MutableListImpl<A>)._length
+
+/**
+ * Returns the last element of the list, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const tail = <A>(self: MutableList<A>): A | undefined => self.tail === undefined ? undefined : self.tail.value
+
+/**
+ * Returns the first element of the list, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const head = <A>(self: MutableList<A>): A | undefined => self.head === undefined ? undefined : self.head.value
+
+/**
+ * Executes the specified function `f` for each element in the list.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach: {
+  <A>(f: (element: A) => void): (self: MutableList<A>) => void
+  <A>(self: MutableList<A>, f: (element: A) => void): void
+} = Dual.dual<
+  <A>(f: (element: A) => void) => (self: MutableList<A>) => void,
+  <A>(self: MutableList<A>, f: (element: A) => void) => void
+>(2, (self, f) => {
+  let current = self.head
+  while (current !== undefined) {
+    f(current.value)
+    current = current.next
+  }
+})
+
+/**
+ * Removes all elements from the doubly-linked list.
+ *
+ * @since 2.0.0
+ */
+export const reset = <A>(self: MutableList<A>): MutableList<A> => {
+  ;(self as MutableListImpl<A>)._length = 0
+  self.head = undefined
+  self.tail = undefined
+  return self
+}
+
+/**
+ * Appends the specified element to the end of the `MutableList`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const append: {
+  <A>(value: A): (self: MutableList<A>) => MutableList<A>
+  <A>(self: MutableList<A>, value: A): MutableList<A>
+} = Dual.dual<
+  <A>(value: A) => (self: MutableList<A>) => MutableList<A>,
+  <A>(self: MutableList<A>, value: A) => MutableList<A>
+>(2, <A>(self: MutableList<A>, value: A) => {
+  const node = new LinkedListNode(value)
+  if (self.head === undefined) {
+    self.head = node
+  }
+  if (self.tail === undefined) {
+    self.tail = node
+  } else {
+    self.tail.next = node
+    node.prev = self.tail
+    self.tail = node
+  }
+  ;(self as MutableListImpl<A>)._length += 1
+  return self
+})
+
+/**
+ * Removes the first value from the list and returns it, if it exists.
+ *
+ * @since 0.0.1
+ */
+export const shift = <A>(self: MutableList<A>): A | undefined => {
+  const head = self.head
+  if (head !== undefined) {
+    remove(self, head)
+    return head.value
+  }
+  return undefined
+}
+
+/**
+ * Removes the last value from the list and returns it, if it exists.
+ *
+ * @since 0.0.1
+ */
+export const pop = <A>(self: MutableList<A>): A | undefined => {
+  const tail = self.tail
+  if (tail !== undefined) {
+    remove(self, tail)
+    return tail.value
+  }
+  return undefined
+}
+
+/**
+ * Prepends the specified value to the beginning of the list.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const prepend: {
+  <A>(value: A): (self: MutableList<A>) => MutableList<A>
+  <A>(self: MutableList<A>, value: A): MutableList<A>
+} = Dual.dual<
+  <A>(value: A) => (self: MutableList<A>) => MutableList<A>,
+  <A>(self: MutableList<A>, value: A) => MutableList<A>
+>(2, <A>(self: MutableList<A>, value: A) => {
+  const node = new LinkedListNode(value)
+  node.next = self.head
+  if (self.head !== undefined) {
+    self.head.prev = node
+  }
+  self.head = node
+  if (self.tail === undefined) {
+    self.tail = node
+  }
+  ;(self as MutableListImpl<A>)._length += 1
+  return self
+})
+
+const remove = <A>(self: MutableList<A>, node: LinkedListNode<A>): void => {
+  if (node.removed) {
+    return
+  }
+  node.removed = true
+  if (node.prev !== undefined && node.next !== undefined) {
+    node.prev.next = node.next
+    node.next.prev = node.prev
+  } else if (node.prev !== undefined) {
+    self.tail = node.prev
+    node.prev.next = undefined
+  } else if (node.next !== undefined) {
+    self.head = node.next
+    node.next.prev = undefined
+  } else {
+    self.tail = undefined
+    self.head = undefined
+  }
+  if ((self as MutableListImpl<A>)._length > 0) {
+    ;(self as MutableListImpl<A>)._length -= 1
+  }
+}