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

package/src/SortedMap.ts

@@ -0,0 +1,229 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal"
+import * as Dual from "./Function"
+import { pipe } from "./Function"
+import * as Hash from "./Hash"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import * as Option from "./Option"
+import type { Order } from "./Order"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+import { isObject } from "./Predicate"
+import * as RBT from "./RedBlackTree"
+
+const TypeId: unique symbol = Symbol.for("effect/SortedMap")
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface SortedMap<K, V> extends Iterable<readonly [K, V]>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+  /** @internal */
+  readonly tree: RBT.RedBlackTree<K, V>
+}
+
+const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
+  [TypeId]: TypeId,
+  [Hash.symbol]<K, V>(this: SortedMap<K, V>): number {
+    return pipe(Hash.hash(this.tree), Hash.combine(Hash.hash("effect/SortedMap")))
+  },
+  [Equal.symbol]<K, V>(this: SortedMap<K, V>, that: unknown): boolean {
+    return isSortedMap(that) && Equal.equals(this.tree, that.tree)
+  },
+  [Symbol.iterator]<K, V>(this: SortedMap<K, V>): Iterator<readonly [K, V]> {
+    return this.tree[Symbol.iterator]()
+  },
+  toString() {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "SortedMap",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeImpl = <K, V>(tree: RBT.RedBlackTree<K, V>): SortedMap<K, V> => {
+  const self = Object.create(SortedMapProto)
+  self.tree = tree
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSortedMap: {
+  <K, V>(u: Iterable<readonly [K, V]>): u is SortedMap<K, V>
+  (u: unknown): u is SortedMap<unknown, unknown>
+} = (u: unknown): u is SortedMap<unknown, unknown> => isObject(u) && TypeId in u
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <K, V = never>(ord: Order<K>): SortedMap<K, V> => makeImpl<K, V>(RBT.empty<K, V>(ord))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = <K>(ord: Order<K>) => <V>(iterable: Iterable<readonly [K, V]>): SortedMap<K, V> =>
+  makeImpl(RBT.fromIterable<K, V>(ord)(iterable))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make =
+  <K>(ord: Order<K>) =>
+  <Entries extends ReadonlyArray<readonly [K, any]>>(...entries: Entries): SortedMap<
+    K,
+    Entries[number] extends (readonly [any, infer V]) ? V : never
+  > => fromIterable(ord)(entries)
+
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+export const isEmpty = <K, V>(self: SortedMap<K, V>): boolean => size(self) === 0
+
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+export const isNonEmpty = <K, V>(self: SortedMap<K, V>): boolean => size(self) > 0
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const entries = <K, V>(self: SortedMap<K, V>): Iterator<readonly [K, V]> => self[Symbol.iterator]()
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const get: {
+  <K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>
+  <K, V>(self: SortedMap<K, V>, key: K): Option.Option<V>
+} = Dual.dual<
+  <K>(key: K) => <V>(self: SortedMap<K, V>) => Option.Option<V>,
+  <K, V>(self: SortedMap<K, V>, key: K) => Option.Option<V>
+>(2, (self, key) => RBT.findFirst(self.tree, key))
+
+/**
+ * Gets the `Order<K>` that the `SortedMap<K, V>` is using.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const getOrder = <K, V>(self: SortedMap<K, V>): Order<K> => RBT.getOrder(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <K>(key: K): <V>(self: SortedMap<K, V>) => boolean
+  <K, V>(self: SortedMap<K, V>, key: K): boolean
+} = Dual.dual<
+  <K>(key: K) => <V>(self: SortedMap<K, V>) => boolean,
+  <K, V>(self: SortedMap<K, V>, key: K) => boolean
+>(2, (self, key) => Option.isSome(get(self, key)))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const headOption = <K, V>(self: SortedMap<K, V>): Option.Option<readonly [K, V]> => RBT.first(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>
+  <K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B): SortedMap<K, B>
+} = Dual.dual<
+  <A, K, B>(f: (a: A, k: K) => B) => (self: SortedMap<K, A>) => SortedMap<K, B>,
+  <K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B) => SortedMap<K, B>
+>(2, <K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B) =>
+  reduce(
+    self,
+    empty<K, B>(RBT.getOrder(self.tree)),
+    (acc, v, k) => set(acc, k, f(v, k))
+  ))
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const keys = <K, V>(self: SortedMap<K, V>): IterableIterator<K> => RBT.keys(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce: {
+  <B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B
+  <K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B): B
+} = Dual.dual<
+  <B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B) => (self: SortedMap<K, A>) => B,
+  <K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B) => B
+>(3, (self, zero, f) => RBT.reduce(self.tree, zero, f))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const remove: {
+  <K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>
+  <K, V>(self: SortedMap<K, V>, key: K): SortedMap<K, V>
+} = Dual.dual<
+  <K>(key: K) => <V>(self: SortedMap<K, V>) => SortedMap<K, V>,
+  <K, V>(self: SortedMap<K, V>, key: K) => SortedMap<K, V>
+>(2, (self, key) => makeImpl(RBT.removeFirst(self.tree, key)))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const set: {
+  <K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>
+  <K, V>(self: SortedMap<K, V>, key: K, value: V): SortedMap<K, V>
+} = Dual.dual<
+  <K, V>(key: K, value: V) => (self: SortedMap<K, V>) => SortedMap<K, V>,
+  <K, V>(self: SortedMap<K, V>, key: K, value: V) => SortedMap<K, V>
+>(3, (self, key, value) =>
+  RBT.has(self.tree, key)
+    ? makeImpl(RBT.insert(RBT.removeFirst(self.tree, key), key, value))
+    : makeImpl(RBT.insert(self.tree, key, value)))
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const size = <K, V>(self: SortedMap<K, V>): number => RBT.size(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const values = <K, V>(self: SortedMap<K, V>): IterableIterator<V> => RBT.values(self.tree)

package/src/SortedSet.ts

@@ -0,0 +1,385 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal"
+import * as Dual from "./Function"
+import { pipe } from "./Function"
+import * as Hash from "./Hash"
+import type { Inspectable } from "./Inspectable"
+import { NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import type { Order } from "./Order"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+import type { Predicate, Refinement } from "./Predicate"
+import { isObject } from "./Predicate"
+import * as RBT from "./RedBlackTree"
+
+const TypeId: unique symbol = Symbol.for("effect/SortedSet")
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface SortedSet<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _A: (_: never) => A
+  }
+  /** @internal */
+  readonly keyTree: RBT.RedBlackTree<A, boolean>
+}
+
+const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
+  [TypeId]: {
+    _A: (_: never) => _
+  },
+  [Hash.symbol]<A>(this: SortedSet<A>): number {
+    return pipe(Hash.hash(this.keyTree), Hash.combine(Hash.hash(TypeId)))
+  },
+  [Equal.symbol]<A>(this: SortedSet<A>, that: unknown): boolean {
+    return isSortedSet(that) && Equal.equals(this.keyTree, that.keyTree)
+  },
+  [Symbol.iterator]<A>(this: SortedSet<A>): Iterator<A> {
+    return RBT.keys(this.keyTree)
+  },
+  toString<A>(this: SortedSet<A>) {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "SortedSet",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const fromTree = <A>(keyTree: RBT.RedBlackTree<A, boolean>): SortedSet<A> => {
+  const a = Object.create(SortedSetProto)
+  a.keyTree = keyTree
+  return a
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSortedSet: {
+  <A>(u: Iterable<A>): u is SortedSet<A>
+  (u: unknown): u is SortedSet<unknown>
+} = (u: unknown): u is SortedSet<unknown> => isObject(u) && TypeId in u
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <A>(O: Order<A>): SortedSet<A> => fromTree(RBT.empty(O))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable = <K>(ord: Order<K>) => (iterable: Iterable<K>): SortedSet<K> =>
+  fromTree(RBT.fromIterable<K, boolean>(ord)(Array.from(iterable).map((k) => [k, true])))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make =
+  <K>(ord: Order<K>) => <Entries extends ReadonlyArray<K>>(...entries: Entries): SortedSet<Entries[number]> =>
+    fromIterable(ord)(entries)
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const add: {
+  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, value: A): SortedSet<A>
+} = Dual.dual<
+  <A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
+  <A>(self: SortedSet<A>, value: A) => SortedSet<A>
+>(2, (self, value) =>
+  RBT.has(self.keyTree, value)
+    ? self
+    : fromTree(RBT.insert(self.keyTree, value, true)))
+
+/**
+ * @since 2.0.0
+ */
+export const difference: {
+  <A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>
+  <A, B extends A>(self: SortedSet<A>, that: Iterable<B>): SortedSet<A>
+} = Dual.dual<
+  <A, B extends A>(that: Iterable<B>) => (self: SortedSet<A>) => SortedSet<A>,
+  <A, B extends A>(self: SortedSet<A>, that: Iterable<B>) => SortedSet<A>
+>(2, <A, B extends A>(self: SortedSet<A>, that: Iterable<B>) => {
+  let out = self
+  for (const value of that) {
+    out = remove<A | B>(out, value)
+  }
+  return out
+})
+
+/**
+ * Check if a predicate holds true for every `SortedSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const every: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => self is SortedSet<B>
+  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
+  <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): self is SortedSet<B>
+  <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
+} = Dual.dual(2, <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): self is SortedSet<B> => {
+  for (const value of self) {
+    if (!refinement(value)) {
+      return false
+    }
+  }
+  return true
+})
+
+/**
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filter: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
+  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
+  <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
+  <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
+} = Dual.dual<
+  {
+    <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
+    <A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
+  },
+  {
+    <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
+    <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
+  }
+>(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {
+  const ord = RBT.getOrder(self.keyTree)
+  let out = empty<A>(ord)
+  for (const value of self) {
+    if (predicate(value)) {
+      out = add(out, value)
+    }
+  }
+  return out
+})
+
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const flatMap: {
+  <B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>
+  <A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>): SortedSet<B>
+} = Dual.dual<
+  <B, A>(O: Order<B>, f: (a: A) => Iterable<B>) => (self: SortedSet<A>) => SortedSet<B>,
+  <A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>) => SortedSet<B>
+>(3, (self, O, f) => {
+  let out = empty(O)
+  forEach(self, (a) => {
+    for (const b of f(a)) {
+      out = add(out, b)
+    }
+  })
+  return out
+})
+
+/**
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach: {
+  <A>(f: (a: A) => void): (self: SortedSet<A>) => void
+  <A>(self: SortedSet<A>, f: (a: A) => void): void
+} = Dual.dual<
+  <A>(f: (a: A) => void) => (self: SortedSet<A>) => void,
+  <A>(self: SortedSet<A>, f: (a: A) => void) => void
+>(2, (self, f) => RBT.forEach(self.keyTree, f))
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <A>(value: A): (self: SortedSet<A>) => boolean
+  <A>(self: SortedSet<A>, value: A): boolean
+} = Dual.dual<
+  <A>(value: A) => (self: SortedSet<A>) => boolean,
+  <A>(self: SortedSet<A>, value: A) => boolean
+>(2, (self, value) => RBT.has(self.keyTree, value))
+
+/**
+ * @since 2.0.0
+ */
+export const intersection: {
+  <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>
+} = Dual.dual<
+  <A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>,
+  <A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>
+>(2, (self, that) => {
+  const ord = RBT.getOrder(self.keyTree)
+  let out = empty(ord)
+  for (const value of that) {
+    if (has(self, value)) {
+      out = add(out, value)
+    }
+  }
+  return out
+})
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const isSubset: {
+  <A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean
+  <A>(self: SortedSet<A>, that: SortedSet<A>): boolean
+} = Dual.dual<
+  <A>(that: SortedSet<A>) => (self: SortedSet<A>) => boolean,
+  <A>(self: SortedSet<A>, that: SortedSet<A>) => boolean
+>(2, (self, that) => every(self, (a) => has(that, a)))
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>
+  <B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B): SortedSet<B>
+} = Dual.dual<
+  <B, A>(O: Order<B>, f: (a: A) => B) => (self: SortedSet<A>) => SortedSet<B>,
+  <B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B) => SortedSet<B>
+>(3, (self, O, f) => {
+  let out = empty(O)
+  forEach(self, (a) => {
+    const b = f(a)
+    if (!has(out, b)) {
+      out = add(out, b)
+    }
+  })
+  return out
+})
+
+/**
+ * @since 2.0.0
+ * @category filtering
+ */
+export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>
+  ): (self: SortedSet<C>) => [SortedSet<Exclude<C, B>>, SortedSet<B>]
+  <B extends A, A = B>(predicate: (a: A) => boolean): (self: SortedSet<B>) => [SortedSet<B>, SortedSet<B>]
+  <C extends A, B extends A, A = C>(
+    self: SortedSet<C>,
+    refinement: Refinement<A, B>
+  ): [SortedSet<Exclude<C, B>>, SortedSet<B>]
+  <B extends A, A = B>(self: SortedSet<B>, predicate: (a: A) => boolean): [SortedSet<B>, SortedSet<B>]
+} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {
+  const ord = RBT.getOrder(self.keyTree)
+  let right = empty(ord)
+  let left = empty(ord)
+  for (const value of self) {
+    if (predicate(value)) {
+      right = add(right, value)
+    } else {
+      left = add(left, value)
+    }
+  }
+  return [left, right] as const
+})
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const remove: {
+  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, value: A): SortedSet<A>
+} = Dual.dual<
+  <A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
+  <A>(self: SortedSet<A>, value: A) => SortedSet<A>
+>(2, (self, value) => fromTree(RBT.removeFirst(self.keyTree, value)))
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const size = <A>(self: SortedSet<A>): number => RBT.size(self.keyTree)
+
+/**
+ * Check if a predicate holds true for some `SortedSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const some: {
+  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
+  <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
+} = Dual.dual<
+  <A>(predicate: Predicate<A>) => (self: SortedSet<A>) => boolean,
+  <A>(self: SortedSet<A>, predicate: Predicate<A>) => boolean
+>(2, (self, predicate) => {
+  for (const value of self) {
+    if (predicate(value)) {
+      return true
+    }
+  }
+  return false
+})
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export const toggle: {
+  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, value: A): SortedSet<A>
+} = Dual.dual<
+  <A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
+  <A>(self: SortedSet<A>, value: A) => SortedSet<A>
+>(2, (self, value) => has(self, value) ? remove(self, value) : add(self, value))
+
+/**
+ * @since 2.0.0
+ */
+export const union: {
+  <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>
+} = Dual.dual<
+  <A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>,
+  <A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>
+>(2, <A>(self: SortedSet<A>, that: Iterable<A>) => {
+  const ord = RBT.getOrder(self.keyTree)
+  let out = empty<A>(ord)
+  for (const value of self) {
+    out = add(value)(out)
+  }
+  for (const value of that) {
+    out = add(value)(out)
+  }
+  return out
+})
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const values = <A>(self: SortedSet<A>): IterableIterator<A> => RBT.keys(self.keyTree)