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

package/src/internal/hashSet.ts

@@ -0,0 +1,323 @@
+import * as Equal from "../Equal.js"
+import { dual } from "../Function.js"
+import * as Hash from "../Hash.js"
+import type { HashMap } from "../HashMap.js"
+import type * as HS from "../HashSet.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { pipeArguments } from "../Pipeable.js"
+import type { Predicate, Refinement } from "../Predicate.js"
+import { hasProperty } from "../Predicate.js"
+import type { NoInfer } from "../Types.js"
+import * as HM from "./hashMap.js"
+
+const HashSetSymbolKey = "effect/HashSet"
+
+/** @internal */
+export const HashSetTypeId: HS.TypeId = Symbol.for(HashSetSymbolKey) as HS.TypeId
+
+/** @internal */
+export interface HashSetImpl<out 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.cached(
+      this,
+      Hash.combine(Hash.hash(this._keyMap))(Hash.hash(HashSetSymbolKey))
+    )
+  },
+  [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 format(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> => hasProperty(u, HashSetTypeId)
+
+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<
+  <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<
+  <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<NoInfer<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(
+  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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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<
+  <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: {
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: HS.HashSet<A>) => HS.HashSet<A>
+  <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): HS.HashSet<B>
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): HS.HashSet<A>
+} = dual(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: {
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): (self: HS.HashSet<A>) => [excluded: HS.HashSet<Exclude<A, B>>, satisfying: HS.HashSet<B>]
+  <A>(
+    predicate: Predicate<NoInfer<A>>
+  ): (self: HS.HashSet<A>) => [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>]
+  <A, B extends A>(
+    self: HS.HashSet<A>,
+    refinement: Refinement<A, B>
+  ): [excluded: HS.HashSet<Exclude<A, B>>, satisfying: HS.HashSet<B>]
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>]
+} = dual(2, <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<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 (predicate(value)) {
+      add(right, value)
+    } else {
+      add(left, value)
+    }
+  }
+  return [endMutation(left), endMutation(right)]
+})

package/src/internal/keyedPool.ts

@@ -0,0 +1,244 @@
+import type * as Deferred from "../Deferred.js"
+import * as Duration from "../Duration.js"
+import type * as Effect from "../Effect.js"
+import * as Equal from "../Equal.js"
+import { dual, pipe } from "../Function.js"
+import * as Hash from "../Hash.js"
+import * as HashMap from "../HashMap.js"
+import type * as KeyedPool from "../KeyedPool.js"
+import * as MutableRef from "../MutableRef.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import type * as Pool from "../Pool.js"
+import * as Predicate from "../Predicate.js"
+import type * as Scope from "../Scope.js"
+import * as core from "./core.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+import * as pool from "./pool.js"
+
+/** @internal */
+const KeyedPoolSymbolKey = "effect/KeyedPool"
+
+/** @internal */
+export const KeyedPoolTypeId: KeyedPool.KeyedPoolTypeId = Symbol.for(
+  KeyedPoolSymbolKey
+) as KeyedPool.KeyedPoolTypeId
+
+const KeyedPoolMapValueSymbol = Symbol.for("effect/KeyedPool/MapValue")
+type KeyedPoolMapValueSymbol = typeof KeyedPoolMapValueSymbol
+
+const keyedPoolVariance = {
+  /* c8 ignore next */
+  _K: (_: unknown) => _,
+  /* c8 ignore next */
+  _E: (_: never) => _,
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+class KeyedPoolImpl<in K, in out A, out E = never> implements KeyedPool.KeyedPool<K, A, E> {
+  readonly [KeyedPoolTypeId] = keyedPoolVariance
+  constructor(
+    readonly getOrCreatePool: (key: K) => Effect.Effect<Pool.Pool<A, E>>,
+    readonly activePools: Effect.Effect<Array<Pool.Pool<A, E>>>
+  ) {}
+  get(key: K): Effect.Effect<A, E, Scope.Scope> {
+    return core.flatMap(this.getOrCreatePool(key), pool.get)
+  }
+  invalidate(item: A): Effect.Effect<void> {
+    return core.flatMap(this.activePools, core.forEachSequentialDiscard((pool) => pool.invalidate(item)))
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+type MapValue<A, E> = Complete<A, E> | Pending<A, E>
+
+class Complete<in out A, out E> implements Equal.Equal {
+  readonly _tag = "Complete"
+  readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
+  constructor(readonly pool: Pool.Pool<A, E>) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.string("effect/KeyedPool/Complete"),
+      Hash.combine(Hash.hash(this.pool)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isComplete(u) && Equal.equals(this.pool, u.pool)
+  }
+}
+
+const isComplete = (u: unknown): u is Complete<unknown, unknown> =>
+  Predicate.isTagged(u, "Complete") && KeyedPoolMapValueSymbol in u
+
+class Pending<in out A, in out E> implements Equal.Equal {
+  readonly _tag = "Pending"
+  readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
+  constructor(readonly deferred: Deferred.Deferred<Pool.Pool<A, E>>) {}
+  [Hash.symbol](): number {
+    return pipe(
+      Hash.string("effect/KeyedPool/Pending"),
+      Hash.combine(Hash.hash(this.deferred)),
+      Hash.cached(this)
+    )
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isPending(u) && Equal.equals(this.deferred, u.deferred)
+  }
+}
+
+const isPending = (u: unknown): u is Pending<unknown, unknown> =>
+  Predicate.isTagged(u, "Pending") && KeyedPoolMapValueSymbol in u
+
+const makeImpl = <K, A, E, R>(
+  get: (key: K) => Effect.Effect<A, E, R>,
+  min: (key: K) => number,
+  max: (key: K) => number,
+  timeToLive: (key: K) => Option.Option<Duration.Duration>
+): Effect.Effect<KeyedPool.KeyedPool<K, A, E>, never, R | Scope.Scope> =>
+  pipe(
+    fiberRuntime.all([
+      core.context<R>(),
+      core.fiberId,
+      core.sync(() => MutableRef.make(HashMap.empty<K, MapValue<A, E>>())),
+      fiberRuntime.scopeMake()
+    ]),
+    core.map(([context, fiberId, map, scope]) => {
+      const getOrCreatePool = (key: K): Effect.Effect<Pool.Pool<A, E>> =>
+        core.suspend(() => {
+          let value: MapValue<A, E> | undefined = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
+          if (value === undefined) {
+            return core.uninterruptibleMask((restore) => {
+              const deferred = core.deferredUnsafeMake<Pool.Pool<A, E>>(fiberId)
+              value = new Pending(deferred)
+              let previous: MapValue<A, E> | undefined = undefined
+              if (HashMap.has(MutableRef.get(map), key)) {
+                previous = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
+              } else {
+                MutableRef.update(map, HashMap.set(key, value as MapValue<A, E>))
+              }
+              if (previous === undefined) {
+                return pipe(
+                  restore(
+                    fiberRuntime.scopeExtend(
+                      pool.makeWithTTL({
+                        acquire: core.provideContext(get(key), context),
+                        min: min(key),
+                        max: max(key),
+                        timeToLive: Option.getOrElse(timeToLive(key), () => Duration.infinity)
+                      }),
+                      scope
+                    )
+                  ),
+                  core.matchCauseEffect({
+                    onFailure: (cause) => {
+                      const current = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
+                      if (Equal.equals(current, value)) {
+                        MutableRef.update(map, HashMap.remove(key))
+                      }
+                      return core.zipRight(
+                        core.deferredFailCause(deferred, cause),
+                        core.failCause(cause)
+                      )
+                    },
+                    onSuccess: (pool) => {
+                      MutableRef.update(map, HashMap.set(key, new Complete(pool) as MapValue<A, E>))
+                      return core.as(
+                        core.deferredSucceed(deferred, pool),
+                        pool
+                      )
+                    }
+                  })
+                )
+              }
+              switch (previous._tag) {
+                case "Complete": {
+                  return core.succeed(previous.pool)
+                }
+                case "Pending": {
+                  return restore(core.deferredAwait(previous.deferred))
+                }
+              }
+            })
+          }
+          switch (value._tag) {
+            case "Complete": {
+              return core.succeed(value.pool)
+            }
+            case "Pending": {
+              return core.deferredAwait(value.deferred)
+            }
+          }
+        })
+      const activePools: Effect.Effect<Array<Pool.Pool<A, E>>> = core.suspend(() =>
+        core.forEachSequential(HashMap.toValues(MutableRef.get(map)), (value) => {
+          switch (value._tag) {
+            case "Complete": {
+              return core.succeed(value.pool)
+            }
+            case "Pending": {
+              return core.deferredAwait(value.deferred)
+            }
+          }
+        })
+      )
+      return new KeyedPoolImpl(getOrCreatePool, activePools)
+    })
+  )
+
+/** @internal */
+export const make = <K, A, E, R>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
+    readonly size: number
+  }
+): Effect.Effect<KeyedPool.KeyedPool<K, A, E>, never, R | Scope.Scope> =>
+  makeImpl(options.acquire, () => options.size, () => options.size, () => Option.none())
+
+/** @internal */
+export const makeWith = <K, A, E, R>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
+    readonly size: (key: K) => number
+  }
+): Effect.Effect<KeyedPool.KeyedPool<K, A, E>, never, R | Scope.Scope> =>
+  makeImpl(options.acquire, options.size, options.size, () => Option.none())
+
+/** @internal */
+export const makeWithTTL = <K, A, E, R>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
+    readonly min: (key: K) => number
+    readonly max: (key: K) => number
+    readonly timeToLive: Duration.DurationInput
+  }
+): Effect.Effect<KeyedPool.KeyedPool<K, A, E>, never, R | Scope.Scope> => {
+  const timeToLive = Duration.decode(options.timeToLive)
+  return makeImpl(options.acquire, options.min, options.max, () => Option.some(timeToLive))
+}
+
+/** @internal */
+export const makeWithTTLBy = <K, A, E, R>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
+    readonly min: (key: K) => number
+    readonly max: (key: K) => number
+    readonly timeToLive: (key: K) => Duration.DurationInput
+  }
+): Effect.Effect<KeyedPool.KeyedPool<K, A, E>, never, R | Scope.Scope> =>
+  makeImpl(options.acquire, options.min, options.max, (key) => Option.some(Duration.decode(options.timeToLive(key))))
+
+/** @internal */
+export const get = dual<
+  <K>(key: K) => <A, E>(self: KeyedPool.KeyedPool<K, A, E>) => Effect.Effect<A, E, Scope.Scope>,
+  <K, A, E>(self: KeyedPool.KeyedPool<K, A, E>, key: K) => Effect.Effect<A, E, Scope.Scope>
+>(2, (self, key) => self.get(key))
+
+/** @internal */
+export const invalidate = dual<
+  <A>(item: A) => <K, E>(self: KeyedPool.KeyedPool<K, A, E>) => Effect.Effect<void>,
+  <K, A, E>(self: KeyedPool.KeyedPool<K, A, E>, item: A) => Effect.Effect<void>
+>(2, (self, item) => self.invalidate(item))