@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/SortedMap.ts

@@ -0,0 +1,287 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal.js"
+import * as Dual from "./Function.js"
+import { pipe } from "./Function.js"
+import * as Hash from "./Hash.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import * as Option from "./Option.js"
+import type { Order } from "./Order.js"
+import type { Pipeable } from "./Pipeable.js"
+import { pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+import * as RBT from "./RedBlackTree.js"
+import type * as Types from "./Types.js"
+
+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<in out K, out V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _K: Types.Invariant<K>
+    readonly _V: Types.Covariant<V>
+  }
+  /** @internal */
+  readonly tree: RBT.RedBlackTree<K, V>
+}
+
+const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
+  [TypeId]: {
+    _K: (_: any) => _,
+    _V: (_: never) => _
+  },
+  [Hash.symbol]<K, V>(this: SortedMap<K, V>): number {
+    return pipe(
+      Hash.hash(this.tree),
+      Hash.combine(Hash.hash("effect/SortedMap")),
+      Hash.cached(this)
+    )
+  },
+  [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<[K, V]> {
+    return this.tree[Symbol.iterator]()
+  },
+  toString() {
+    return format(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> => hasProperty(u, TypeId)
+
+/**
+ * @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))
+
+/**
+ * Creates a new `SortedMap` from an iterable collection of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: {
+  <B>(ord: Order<B>): <K extends B, V>(iterable: Iterable<readonly [K, V]>) => SortedMap<K, V>
+  <K extends B, V, B>(iterable: Iterable<readonly [K, V]>, ord: Order<B>): SortedMap<K, V>
+} = Dual.dual(
+  2,
+  <K extends B, V, B>(iterable: Iterable<readonly [K, V]>, ord: Order<B>): SortedMap<K, V> =>
+    makeImpl(RBT.fromIterable(iterable, ord))
+)
+
+/**
+ * @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 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<[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 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 keys = <K, V>(self: SortedMap<K, V>): IterableIterator<K> => RBT.keys(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const values = <K, V>(self: SortedMap<K, V>): IterableIterator<V> => RBT.values(self.tree)
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const entries = <K, V>(self: SortedMap<K, V>): IterableIterator<[K, V]> => {
+  const iterator: any = self.tree[Symbol.iterator]()
+  iterator[Symbol.iterator] = () => entries(self)
+  return iterator
+}
+
+/**
+ * @since 3.1.0
+ * @category elements
+ */
+export const lastOption = <K, V>(self: SortedMap<K, V>): Option.Option<[K, V]> => RBT.last(self.tree)
+
+/**
+ * @since 3.1.0
+ * @category filtering
+ */
+export const partition: {
+  <K, V>(
+    predicate: (a: Types.NoInfer<K>) => boolean
+  ): (self: SortedMap<K, V>) => [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
+  <K, V>(self: SortedMap<K, V>, predicate: (a: K) => boolean): [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>]
+} = Dual.dual(
+  2,
+  <K, V>(
+    self: SortedMap<K, V>,
+    predicate: (a: K) => boolean
+  ): [excluded: SortedMap<K, V>, satisfying: SortedMap<K, V>] => {
+    const ord = RBT.getOrder(self.tree)
+    let right = empty<K, V>(ord)
+    let left = empty<K, V>(ord)
+    for (const value of self) {
+      if (predicate(value[0])) {
+        right = set(right, value[0], value[1])
+      } else {
+        left = set(left, value[0], value[1])
+      }
+    }
+    return [left, right]
+  }
+)

package/src/SortedSet.ts

@@ -0,0 +1,390 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal.js"
+import type * as Equivalence from "./Equivalence.js"
+import * as Dual from "./Function.js"
+import { pipe } from "./Function.js"
+import * as Hash from "./Hash.js"
+import type { Inspectable } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import type { Order } from "./Order.js"
+import type { Pipeable } from "./Pipeable.js"
+import { pipeArguments } from "./Pipeable.js"
+import type { Predicate } from "./Predicate.js"
+import { hasProperty } from "./Predicate.js"
+import * as RBT from "./RedBlackTree.js"
+import type { Invariant, NoInfer } from "./Types.js"
+
+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<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _A: Invariant<A>
+  }
+  /** @internal */
+  readonly keyTree: RBT.RedBlackTree<A, boolean>
+}
+
+const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
+  [TypeId]: {
+    _A: (_: any) => _
+  },
+  [Hash.symbol]<A>(this: SortedSet<A>): number {
+    return pipe(
+      Hash.hash(this.keyTree),
+      Hash.combine(Hash.hash(TypeId)),
+      Hash.cached(this)
+    )
+  },
+  [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 format(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> => hasProperty(u, TypeId)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty = <A>(O: Order<A>): SortedSet<A> => fromTree(RBT.empty(O))
+
+/**
+ * Creates a new `SortedSet` from an iterable collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: {
+  <B>(ord: Order<B>): <A extends B>(iterable: Iterable<A>) => SortedSet<A>
+  <A extends B, B>(iterable: Iterable<A>, ord: Order<B>): SortedSet<A>
+} = Dual.dual(
+  2,
+  <A extends B, B>(iterable: Iterable<A>, ord: Order<B>): SortedSet<A> =>
+    fromTree(RBT.fromIterable(Array.from(iterable).map((k) => [k, true]), ord))
+)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make =
+  <K>(ord: Order<K>) => <Entries extends ReadonlyArray<K>>(...entries: Entries): SortedSet<Entries[number]> =>
+    fromIterable(entries, ord)
+
+/**
+ * @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>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
+  <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
+} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean => {
+  for (const value of self) {
+    if (!predicate(value)) {
+      return false
+    }
+  }
+  return true
+})
+
+/**
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filter: {
+  <A, B extends A>(predicate: Predicate<B>): (self: SortedSet<A>) => SortedSet<A>
+  <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
+} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<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: {
+  <A>(
+    predicate: (a: NoInfer<A>) => boolean
+  ): (self: SortedSet<A>) => [excluded: SortedSet<A>, satisfying: SortedSet<A>]
+  <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<A>]
+} = Dual.dual(
+  2,
+  <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<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]
+  }
+)
+
+/**
+ * @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)
+
+/**
+ * @since 2.0.0
+ * @category equivalence
+ */
+export const getEquivalence = <A>(): Equivalence.Equivalence<SortedSet<A>> => (a, b) => isSubset(a, b) && isSubset(b, a)