@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/hashSet.ts

@@ -1,323 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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))