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

package/src/internal/HashSet.ts

@@ -0,0 +1,319 @@
+import * as Equal from "../Equal"
+import * as Dual from "../Function"
+import * as Hash from "../Hash"
+import type { HashMap } from "../HashMap"
+import type * as HS from "../HashSet"
+import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
+import * as HM from "../internal/HashMap"
+import { pipeArguments } from "../Pipeable"
+import type { Predicate, Refinement } from "../Predicate"
+import { isObject } from "../Predicate"
+
+/** @internal */
+export const HashSetTypeId: HS.TypeId = Symbol.for("effect/HashSet") as HS.TypeId
+
+/** @internal */
+export interface HashSetImpl<A> extends HS.HashSet<A> {
+  readonly _keyMap: HashMap<A, unknown>
+}
+
+const HashSetProto: Omit<HashSetImpl<unknown>, "_keyMap"> = {
+  [HashSetTypeId]: HashSetTypeId,
+  [Symbol.iterator]<A>(this: HashSetImpl<A>): Iterator<A> {
+    return HM.keys(this._keyMap)
+  },
+  [Hash.symbol]<A>(this: HashSetImpl<A>): number {
+    return Hash.combine(Hash.hash(this._keyMap))(Hash.hash("HashSet"))
+  },
+  [Equal.symbol]<A>(this: HashSetImpl<A>, that: unknown): boolean {
+    if (isHashSet(that)) {
+      return (
+        HM.size(this._keyMap) === HM.size((that as HashSetImpl<A>)._keyMap) &&
+        Equal.equals(this._keyMap, (that as HashSetImpl<A>)._keyMap)
+      )
+    }
+    return false
+  },
+  toString() {
+    return toString(this.toJSON())
+  },
+  toJSON() {
+    return {
+      _id: "HashSet",
+      values: Array.from(this).map(toJSON)
+    }
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON()
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const makeImpl = <A>(keyMap: HashMap<A, unknown>): HashSetImpl<A> => {
+  const set = Object.create(HashSetProto)
+  set._keyMap = keyMap
+  return set
+}
+
+/** @internal */
+export const isHashSet: {
+  <A>(u: Iterable<A>): u is HS.HashSet<A>
+  (u: unknown): u is HS.HashSet<unknown>
+} = (u: unknown): u is HS.HashSet<unknown> => isObject(u) && HashSetTypeId in u
+
+const _empty = makeImpl<never>(HM.empty())
+
+/** @internal */
+export const empty = <A = never>(): HS.HashSet<A> => _empty
+
+/** @internal */
+export const fromIterable = <A>(elements: Iterable<A>): HS.HashSet<A> => {
+  const set = beginMutation(empty<A>())
+  for (const value of elements) {
+    add(set, value)
+  }
+  return endMutation(set)
+}
+
+/** @internal */
+export const make = <As extends ReadonlyArray<any>>(...elements: As): HS.HashSet<As[number]> => {
+  const set = beginMutation(empty<As[number]>())
+  for (const value of elements) {
+    add(set, value)
+  }
+  return endMutation(set)
+}
+
+/** @internal */
+export const has = Dual.dual<
+  <A>(value: A) => (self: HS.HashSet<A>) => boolean,
+  <A>(self: HS.HashSet<A>, value: A) => boolean
+>(2, <A>(self: HS.HashSet<A>, value: A) => HM.has((self as HashSetImpl<A>)._keyMap, value))
+
+/** @internal */
+export const some = Dual.dual<
+  <A>(f: Predicate<A>) => (self: HS.HashSet<A>) => boolean,
+  <A>(self: HS.HashSet<A>, f: Predicate<A>) => boolean
+>(2, (self, f) => {
+  let found = false
+  for (const value of self) {
+    found = f(value)
+    if (found) {
+      break
+    }
+  }
+  return found
+})
+
+/** @internal */
+export const every: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HS.HashSet<A>) => self is HS.HashSet<B>
+  <A>(predicate: Predicate<A>): (self: HS.HashSet<A>) => boolean
+  <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): self is HS.HashSet<B>
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): boolean
+} = Dual.dual(
+  2,
+  <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): self is HS.HashSet<B> =>
+    !some(self, (a) => !refinement(a))
+)
+
+/** @internal */
+export const isSubset = Dual.dual<
+  <A>(that: HS.HashSet<A>) => (self: HS.HashSet<A>) => boolean,
+  <A>(self: HS.HashSet<A>, that: HS.HashSet<A>) => boolean
+>(2, (self, that) => every(self, (value) => has(that, value)))
+
+/** @internal */
+export const values = <A>(self: HS.HashSet<A>): IterableIterator<A> => HM.keys((self as HashSetImpl<A>)._keyMap)
+
+/** @internal */
+export const size = <A>(self: HS.HashSet<A>): number => HM.size((self as HashSetImpl<A>)._keyMap)
+
+/** @internal */
+export const beginMutation = <A>(self: HS.HashSet<A>): HS.HashSet<A> =>
+  makeImpl(HM.beginMutation((self as HashSetImpl<A>)._keyMap))
+
+/** @internal */
+export const endMutation = <A>(self: HS.HashSet<A>): HS.HashSet<A> => {
+  ;((self as HashSetImpl<A>)._keyMap as HM.HashMapImpl<A, unknown>)._editable = false
+  return self
+}
+
+/** @internal */
+export const mutate = Dual.dual<
+  <A>(f: (set: HS.HashSet<A>) => void) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, f: (set: HS.HashSet<A>) => void) => HS.HashSet<A>
+>(2, (self, f) => {
+  const transient = beginMutation(self)
+  f(transient)
+  return endMutation(transient)
+})
+
+/** @internal */
+export const add = Dual.dual<
+  <A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
+>(
+  2,
+  <A>(self: HS.HashSet<A>, value: A) =>
+    ((self as HashSetImpl<A>)._keyMap as HM.HashMapImpl<A, unknown>)._editable
+      ? (HM.set(value as A, true as unknown)((self as HashSetImpl<A>)._keyMap), self)
+      : makeImpl(HM.set(value as A, true as unknown)((self as HashSetImpl<A>)._keyMap))
+)
+
+/** @internal */
+export const remove = Dual.dual<
+  <A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
+>(
+  2,
+  <A>(self: HS.HashSet<A>, value: A) =>
+    (((self as HashSetImpl<A>)._keyMap) as HM.HashMapImpl<A, unknown>)._editable
+      ? (HM.remove(value)((self as HashSetImpl<A>)._keyMap), self)
+      : makeImpl(HM.remove(value)((self as HashSetImpl<A>)._keyMap))
+)
+
+/** @internal */
+export const difference = Dual.dual<
+  <A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
+>(2, (self, that) =>
+  mutate(self, (set) => {
+    for (const value of that) {
+      remove(set, value)
+    }
+  }))
+
+/** @internal */
+export const intersection = Dual.dual<
+  <A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
+>(2, (self, that) =>
+  mutate(empty(), (set) => {
+    for (const value of that) {
+      if (has(value)(self)) {
+        add(value)(set)
+      }
+    }
+  }))
+
+/** @internal */
+export const union = Dual.dual<
+  <A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
+>(2, (self, that) =>
+  mutate(empty(), (set) => {
+    forEach(self, (value) => add(set, value))
+    for (const value of that) {
+      add(set, value)
+    }
+  }))
+
+/** @internal */
+export const toggle = Dual.dual<
+  <A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
+  <A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
+>(2, (self, value) => has(self, value) ? remove(self, value) : add(self, value))
+
+/** @internal */
+export const map = Dual.dual<
+  <A, B>(f: (a: A) => B) => (self: HS.HashSet<A>) => HS.HashSet<B>,
+  <A, B>(self: HS.HashSet<A>, f: (a: A) => B) => HS.HashSet<B>
+>(2, (self, f) =>
+  mutate(empty(), (set) => {
+    forEach(self, (a) => {
+      const b = f(a)
+      if (!has(set, b)) {
+        add(set, b)
+      }
+    })
+  }))
+
+/** @internal */
+export const flatMap = Dual.dual<
+  <A, B>(f: (a: A) => Iterable<B>) => (self: HS.HashSet<A>) => HS.HashSet<B>,
+  <A, B>(self: HS.HashSet<A>, f: (a: A) => Iterable<B>) => HS.HashSet<B>
+>(2, (self, f) =>
+  mutate(empty(), (set) => {
+    forEach(self, (a) => {
+      for (const b of f(a)) {
+        if (!has(set, b)) {
+          add(set, b)
+        }
+      }
+    })
+  }))
+
+/** @internal */
+export const forEach = Dual.dual<
+  <A>(f: (value: A) => void) => (self: HS.HashSet<A>) => void,
+  <A>(self: HS.HashSet<A>, f: (value: A) => void) => void
+>(2, <A>(self: HS.HashSet<A>, f: (value: A) => void) =>
+  HM.forEach(
+    (self as HashSetImpl<A>)._keyMap,
+    (_, k) => f(k)
+  ))
+
+/** @internal */
+export const reduce = Dual.dual<
+  <A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: HS.HashSet<A>) => Z,
+  <A, Z>(self: HS.HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => Z
+>(3, <A, Z>(self: HS.HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) =>
+  HM.reduce(
+    (self as HashSetImpl<A>)._keyMap,
+    zero,
+    (z, _, a) => f(z, a)
+  ))
+
+/** @internal */
+export const filter = Dual.dual<
+  {
+    <A, B extends A>(f: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
+    <A>(f: Predicate<A>): (self: HS.HashSet<A>) => HS.HashSet<A>
+  },
+  {
+    <A, B extends A>(self: HS.HashSet<A>, f: Refinement<A, B>): HS.HashSet<B>
+    <A>(self: HS.HashSet<A>, f: Predicate<A>): HS.HashSet<A>
+  }
+>(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+  return mutate(empty(), (set) => {
+    const iterator = values(self)
+    let next: IteratorResult<A, any>
+    while (!(next = iterator.next()).done) {
+      const value = next.value
+      if (f(value)) {
+        add(set, value)
+      }
+    }
+  })
+})
+
+/** @internal */
+export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>
+  ): (self: HS.HashSet<C>) => [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
+  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HS.HashSet<B>) => [HS.HashSet<B>, HS.HashSet<B>]
+  <C extends A, B extends A, A = C>(
+    self: HS.HashSet<C>,
+    refinement: Refinement<A, B>
+  ): [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
+  <B extends A, A = B>(self: HS.HashSet<B>, predicate: (a: A) => boolean): [HS.HashSet<B>, HS.HashSet<B>]
+} = Dual.dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+  const iterator = values(self)
+  let next: IteratorResult<A, any>
+  const right = beginMutation(empty<A>())
+  const left = beginMutation(empty<A>())
+  while (!(next = iterator.next()).done) {
+    const value = next.value
+    if (f(value)) {
+      add(right, value)
+    } else {
+      add(left, value)
+    }
+  }
+  return [endMutation(left), endMutation(right)] as const
+})

package/src/internal/Iterable.ts

@@ -0,0 +1,54 @@
+/** @internal */
+export function concat<B>(that: Iterable<B>) {
+  return <A>(self: Iterable<A>): Iterable<A | B> => {
+    return {
+      [Symbol.iterator]() {
+        const iterA = self[Symbol.iterator]()
+        let doneA = false
+        let iterB: Iterator<B>
+        return {
+          next() {
+            if (!doneA) {
+              const r = iterA.next()
+              if (r.done) {
+                doneA = true
+                iterB = that[Symbol.iterator]()
+                return iterB.next()
+              }
+              return r
+            }
+            return iterB.next()
+          }
+        }
+      }
+    }
+  }
+}
+
+/** @internal */
+export function reduce<A, B>(b: B, f: (s: B, a: A) => B) {
+  return function(iterable: Iterable<A>): B {
+    if (Array.isArray(iterable)) {
+      return iterable.reduce(f, b)
+    }
+    let result = b
+    for (const n of iterable) {
+      result = f(result, n)
+    }
+    return result
+  }
+}
+
+/** @internal */
+export function map<A, B>(f: (a: A) => B) {
+  return function(iterable: Iterable<A>): Iterable<B> {
+    if (Array.isArray(iterable)) {
+      return iterable.map(f)
+    }
+    return (function*() {
+      for (const n of iterable) {
+        yield f(n)
+      }
+    })()
+  }
+}

package/src/internal/Option.ts

@@ -0,0 +1,79 @@
+/**
+ * @since 2.0.0
+ */
+
+import * as Equal from "../Equal"
+import * as Hash from "../Hash"
+import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
+import type * as Option from "../Option"
+import { EffectPrototype } from "./Effectable"
+
+const TypeId: Option.TypeId = Symbol.for("effect/Option") as Option.TypeId
+
+const CommonProto = {
+  ...EffectPrototype,
+  [TypeId]: {
+    _A: (_: never) => _
+  },
+  [NodeInspectSymbol]<A>(this: Option.Option<A>) {
+    return this.toJSON()
+  },
+  toString<A>(this: Option.Option<A>) {
+    return toString(this.toJSON())
+  }
+}
+
+const SomeProto = Object.assign(Object.create(CommonProto), {
+  _tag: "Some",
+  _op: "Some",
+  [Equal.symbol]<A>(this: Option.Some<A>, that: unknown): boolean {
+    return isOption(that) && isSome(that) && Equal.equals(that.value, this.value)
+  },
+  [Hash.symbol]<A>(this: Option.Some<A>) {
+    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.value))
+  },
+  toJSON<A>(this: Option.Some<A>) {
+    return {
+      _id: "Option",
+      _tag: this._tag,
+      value: toJSON(this.value)
+    }
+  }
+})
+
+const NoneProto = Object.assign(Object.create(CommonProto), {
+  _tag: "None",
+  _op: "None",
+  [Equal.symbol]<A>(this: Option.None<A>, that: unknown): boolean {
+    return isOption(that) && isNone(that)
+  },
+  [Hash.symbol]<A>(this: Option.None<A>) {
+    return Hash.combine(Hash.hash(this._tag))
+  },
+  toJSON<A>(this: Option.None<A>) {
+    return {
+      _id: "Option",
+      _tag: this._tag
+    }
+  }
+})
+
+/** @internal */
+export const isOption = (input: unknown): input is Option.Option<unknown> =>
+  typeof input === "object" && input != null && TypeId in input
+
+/** @internal */
+export const isNone = <A>(fa: Option.Option<A>): fa is Option.None<A> => fa._tag === "None"
+
+/** @internal */
+export const isSome = <A>(fa: Option.Option<A>): fa is Option.Some<A> => fa._tag === "Some"
+
+/** @internal */
+export const none: Option.Option<never> = Object.create(NoneProto)
+
+/** @internal */
+export const some = <A>(value: A): Option.Option<A> => {
+  const a = Object.create(SomeProto)
+  a.value = value
+  return a
+}

package/src/internal/ReadonlyArray.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 2.0.0
+ */
+
+import type { NonEmptyArray } from "../ReadonlyArray"
+
+/** @internal */
+export const isNonEmptyArray = <A>(self: ReadonlyArray<A>): self is NonEmptyArray<A> => self.length > 0

package/src/internal/RedBlackTree/iterator.ts

@@ -0,0 +1,207 @@
+import type { RedBlackTreeImpl } from "../../internal/RedBlackTree"
+import type * as Node from "../../internal/RedBlackTree/node"
+import * as Option from "../../Option"
+import type * as RBT from "../../RedBlackTree"
+
+/** @internal */
+export const Direction = {
+  Forward: 0 as RBT.RedBlackTree.Direction,
+  Backward: 1 << 0 as RBT.RedBlackTree.Direction
+} as const
+
+/** @internal */
+export class RedBlackTreeIterator<K, V> implements Iterator<readonly [K, V]> {
+  private count = 0
+
+  constructor(
+    readonly self: RBT.RedBlackTree<K, V>,
+    readonly stack: Array<Node.Node<K, V>>,
+    readonly direction: RBT.RedBlackTree.Direction
+  ) {}
+
+  /**
+   * Clones the iterator
+   */
+  clone(): RedBlackTreeIterator<K, V> {
+    return new RedBlackTreeIterator(this.self, this.stack.slice(), this.direction)
+  }
+
+  /**
+   * Reverse the traversal direction
+   */
+  reversed(): RedBlackTreeIterator<K, V> {
+    return new RedBlackTreeIterator(
+      this.self,
+      this.stack.slice(),
+      this.direction === Direction.Forward ? Direction.Backward : Direction.Forward
+    )
+  }
+
+  /**
+   * Iterator next
+   */
+  next(): IteratorResult<readonly [K, V], number> {
+    const entry = this.entry
+    this.count++
+    if (this.direction === Direction.Forward) {
+      this.moveNext()
+    } else {
+      this.movePrev()
+    }
+    switch (entry._tag) {
+      case "None": {
+        return { done: true, value: this.count }
+      }
+      case "Some": {
+        return { done: false, value: entry.value }
+      }
+    }
+  }
+
+  /**
+   * Returns the key
+   */
+  get key(): Option.Option<K> {
+    if (this.stack.length > 0) {
+      return Option.some(this.stack[this.stack.length - 1]!.key)
+    }
+    return Option.none()
+  }
+
+  /**
+   * Returns the value
+   */
+  get value(): Option.Option<V> {
+    if (this.stack.length > 0) {
+      return Option.some(this.stack[this.stack.length - 1]!.value)
+    }
+    return Option.none()
+  }
+
+  /**
+   * Returns the key
+   */
+  get entry(): Option.Option<readonly [K, V]> {
+    if (this.stack.length > 0) {
+      return Option.some(
+        [
+          this.stack[this.stack.length - 1]!.key,
+          this.stack[this.stack.length - 1]!.value
+        ]
+      )
+    }
+    return Option.none()
+  }
+
+  /**
+   * Returns the position of this iterator in the sorted list
+   */
+  get index(): number {
+    let idx = 0
+    const stack = this.stack
+    if (stack.length === 0) {
+      const r = (this.self as RedBlackTreeImpl<K, V>)._root
+      if (r != null) {
+        return r.count
+      }
+      return 0
+    } else if (stack[stack.length - 1]!.left != null) {
+      idx = stack[stack.length - 1]!.left!.count
+    }
+    for (let s = stack.length - 2; s >= 0; --s) {
+      if (stack[s + 1] === stack[s]!.right) {
+        ;++idx
+        if (stack[s]!.left != null) {
+          idx += stack[s]!.left!.count
+        }
+      }
+    }
+    return idx
+  }
+
+  /**
+   * Advances iterator to next element in list
+   */
+  moveNext() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return
+    }
+    let n: Node.Node<K, V> | undefined = stack[stack.length - 1]!
+    if (n.right != null) {
+      n = n.right
+      while (n != null) {
+        stack.push(n)
+        n = n.left
+      }
+    } else {
+      stack.pop()
+      while (stack.length > 0 && stack[stack.length - 1]!.right === n) {
+        n = stack[stack.length - 1]
+        stack.pop()
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a next element
+   */
+  get hasNext() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return false
+    }
+    if (stack[stack.length - 1]!.right != null) {
+      return true
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.left === stack[s]) {
+        return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Advances iterator to previous element in list
+   */
+  movePrev() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return
+    }
+    let n: Node.Node<K, V> | undefined = stack[stack.length - 1]
+    if (n != null && n.left != null) {
+      n = n.left
+      while (n != null) {
+        stack.push(n)
+        n = n.right
+      }
+    } else {
+      stack.pop()
+      while (stack.length > 0 && stack[stack.length - 1]!.left === n) {
+        n = stack[stack.length - 1]
+        stack.pop()
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a previous element
+   */
+  get hasPrev() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return false
+    }
+    if (stack[stack.length - 1]!.left != null) {
+      return true
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.right === stack[s]) {
+        return true
+      }
+    }
+    return false
+  }
+}