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

package/src/internal/random.ts

@@ -1,161 +0,0 @@
-import type * as Arr from "../Array.js"
-import * as Chunk from "../Chunk.js"
-import * as Context from "../Context.js"
-import type * as Effect from "../Effect.js"
-import { pipe } from "../Function.js"
-import * as Hash from "../Hash.js"
-import type * as Random from "../Random.js"
-import * as PCGRandom from "../Utils.js"
-import * as core from "./core.js"
-
-/** @internal */
-const RandomSymbolKey = "effect/Random"
-
-/** @internal */
-export const RandomTypeId: Random.RandomTypeId = Symbol.for(
-  RandomSymbolKey
-) as Random.RandomTypeId
-
-/** @internal */
-export const randomTag: Context.Tag<Random.Random, Random.Random> = Context.GenericTag("effect/Random")
-/** @internal */
-class RandomImpl implements Random.Random {
-  readonly [RandomTypeId]: Random.RandomTypeId = RandomTypeId
-
-  readonly PRNG: PCGRandom.PCGRandom
-
-  constructor(readonly seed: number) {
-    this.PRNG = new PCGRandom.PCGRandom(seed)
-  }
-
-  get next(): Effect.Effect<number> {
-    return core.sync(() => this.PRNG.number())
-  }
-
-  get nextBoolean(): Effect.Effect<boolean> {
-    return core.map(this.next, (n) => n > 0.5)
-  }
-
-  get nextInt(): Effect.Effect<number> {
-    return core.sync(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER))
-  }
-
-  nextRange(min: number, max: number): Effect.Effect<number> {
-    return core.map(this.next, (n) => (max - min) * n + min)
-  }
-
-  nextIntBetween(min: number, max: number): Effect.Effect<number> {
-    return core.sync(() => this.PRNG.integer(max - min) + min)
-  }
-
-  shuffle<A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> {
-    return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
-  }
-}
-
-const shuffleWith = <A>(
-  elements: Iterable<A>,
-  nextIntBounded: (n: number) => Effect.Effect<number>
-): Effect.Effect<Chunk.Chunk<A>> => {
-  return core.suspend(() =>
-    pipe(
-      core.sync(() => Array.from(elements)),
-      core.flatMap((buffer) => {
-        const numbers: Array<number> = []
-        for (let i = buffer.length; i >= 2; i = i - 1) {
-          numbers.push(i)
-        }
-        return pipe(
-          numbers,
-          core.forEachSequentialDiscard((n) =>
-            pipe(
-              nextIntBounded(n),
-              core.map((k) => swap(buffer, n - 1, k))
-            )
-          ),
-          core.as(Chunk.fromIterable(buffer))
-        )
-      })
-    )
-  )
-}
-
-const swap = <A>(buffer: Array<A>, index1: number, index2: number): Array<A> => {
-  const tmp = buffer[index1]!
-  buffer[index1] = buffer[index2]!
-  buffer[index2] = tmp
-  return buffer
-}
-
-export const make = <A>(seed: A): Random.Random => new RandomImpl(Hash.hash(seed))
-
-/** @internal */
-class FixedRandomImpl implements Random.Random {
-  readonly [RandomTypeId]: Random.RandomTypeId = RandomTypeId
-
-  private index = 0
-
-  constructor(readonly values: Arr.NonEmptyArray<any>) {
-    if (values.length === 0) {
-      throw new Error("Requires at least one value")
-    }
-  }
-
-  private getNextValue(): any {
-    const value = this.values[this.index]
-    this.index = (this.index + 1) % this.values.length
-    return value
-  }
-
-  get next(): Effect.Effect<number> {
-    return core.sync(() => {
-      const value = this.getNextValue()
-      if (typeof value === "number") {
-        return Math.max(0, Math.min(1, value))
-      }
-      return Hash.hash(value) / 2147483647
-    })
-  }
-
-  get nextBoolean(): Effect.Effect<boolean> {
-    return core.sync(() => {
-      const value = this.getNextValue()
-      if (typeof value === "boolean") {
-        return value
-      }
-      return Hash.hash(value) % 2 === 0
-    })
-  }
-
-  get nextInt(): Effect.Effect<number> {
-    return core.sync(() => {
-      const value = this.getNextValue()
-      if (typeof value === "number" && Number.isFinite(value)) {
-        return Math.round(value)
-      }
-      return Math.abs(Hash.hash(value))
-    })
-  }
-
-  nextRange(min: number, max: number): Effect.Effect<number> {
-    return core.map(this.next, (n) => (max - min) * n + min)
-  }
-
-  nextIntBetween(min: number, max: number): Effect.Effect<number> {
-    return core.sync(() => {
-      const value = this.getNextValue()
-      if (typeof value === "number" && Number.isFinite(value)) {
-        return Math.max(min, Math.min(max - 1, Math.round(value)))
-      }
-      const hash = Math.abs(Hash.hash(value))
-      return min + (hash % (max - min))
-    })
-  }
-
-  shuffle<A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> {
-    return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
-  }
-}
-
-/** @internal */
-export const fixed = <T extends Arr.NonEmptyArray<any>>(values: T): Random.Random => new FixedRandomImpl(values)

package/src/internal/rateLimiter.ts

@@ -1,93 +0,0 @@
-import type { DurationInput } from "../Duration.js"
-import * as Duration from "../Duration.js"
-import * as Effect from "../Effect.js"
-import * as FiberRef from "../FiberRef.js"
-import { pipe } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
-import type * as RateLimiter from "../RateLimiter.js"
-import type * as Scope from "../Scope.js"
-
-/** @internal */
-export const make = ({
-  algorithm = "token-bucket",
-  interval,
-  limit
-}: RateLimiter.RateLimiter.Options): Effect.Effect<
-  RateLimiter.RateLimiter,
-  never,
-  Scope.Scope
-> => {
-  switch (algorithm) {
-    case "fixed-window": {
-      return fixedWindow(limit, interval)
-    }
-    case "token-bucket": {
-      return tokenBucket(limit, interval)
-    }
-  }
-}
-
-const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
-  RateLimiter.RateLimiter,
-  never,
-  Scope.Scope
-> =>
-  Effect.gen(function*() {
-    const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
-    const semaphore = yield* Effect.makeSemaphore(limit)
-    const latch = yield* Effect.makeSemaphore(0)
-    const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
-      Effect.zipRight(latch.releaseAll),
-      Effect.zipRight(semaphore.release(1)),
-      Effect.flatMap((free) => free === limit ? Effect.void : refill)
-    )
-    yield* pipe(
-      latch.take(1),
-      Effect.zipRight(refill),
-      Effect.forever,
-      Effect.forkScoped,
-      Effect.interruptible
-    )
-    const take = Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(
-        FiberRef.get(currentCost),
-        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
-      )
-    )
-    return (effect) => Effect.zipRight(take, effect)
-  })
-
-const fixedWindow = (limit: number, window: DurationInput): Effect.Effect<
-  RateLimiter.RateLimiter,
-  never,
-  Scope.Scope
-> =>
-  Effect.gen(function*() {
-    const semaphore = yield* Effect.makeSemaphore(limit)
-    const latch = yield* Effect.makeSemaphore(0)
-    yield* pipe(
-      latch.take(1),
-      Effect.zipRight(Effect.sleep(window)),
-      Effect.zipRight(latch.releaseAll),
-      Effect.zipRight(semaphore.releaseAll),
-      Effect.forever,
-      Effect.forkScoped,
-      Effect.interruptible
-    )
-    const take = Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(
-        FiberRef.get(currentCost),
-        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
-      )
-    )
-    return (effect) => Effect.zipRight(take, effect)
-  })
-
-/** @internal */
-const currentCost = globalValue(
-  Symbol.for("effect/RateLimiter/currentCost"),
-  () => FiberRef.unsafeMake(1)
-)
-
-/** @internal */
-export const withCost = (cost: number) => Effect.locally(currentCost, cost)

package/src/internal/rcMap.ts

@@ -1,285 +0,0 @@
-import type * as Cause from "../Cause.js"
-import * as Context from "../Context.js"
-import type * as Deferred from "../Deferred.js"
-import * as Duration from "../Duration.js"
-import type { Effect } from "../Effect.js"
-import type { RuntimeFiber } from "../Fiber.js"
-import { dual, identity } from "../Function.js"
-import * as MutableHashMap from "../MutableHashMap.js"
-import { pipeArguments } from "../Pipeable.js"
-import type * as RcMap from "../RcMap.js"
-import type * as Scope from "../Scope.js"
-import * as coreEffect from "./core-effect.js"
-import * as core from "./core.js"
-import * as circular from "./effect/circular.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-
-/** @internal */
-export const TypeId: RcMap.TypeId = Symbol.for("effect/RcMap") as RcMap.TypeId
-
-type State<K, A, E> = State.Open<K, A, E> | State.Closed
-
-declare namespace State {
-  interface Open<K, A, E> {
-    readonly _tag: "Open"
-    readonly map: MutableHashMap.MutableHashMap<K, Entry<A, E>>
-  }
-
-  interface Closed {
-    readonly _tag: "Closed"
-  }
-
-  interface Entry<A, E> {
-    readonly deferred: Deferred.Deferred<A, E>
-    readonly scope: Scope.CloseableScope
-    readonly finalizer: Effect<void>
-    fiber: RuntimeFiber<void, never> | undefined
-    expiresAt: number
-    refCount: number
-  }
-}
-
-const variance: RcMap.RcMap.Variance<any, any, any> = {
-  _K: identity,
-  _A: identity,
-  _E: identity
-}
-
-class RcMapImpl<K, A, E> implements RcMap.RcMap<K, A, E> {
-  readonly [TypeId]: RcMap.RcMap.Variance<K, A, E>
-
-  state: State<K, A, E> = {
-    _tag: "Open",
-    map: MutableHashMap.empty()
-  }
-  readonly semaphore = circular.unsafeMakeSemaphore(1)
-
-  constructor(
-    readonly lookup: (key: K) => Effect<A, E, Scope.Scope>,
-    readonly context: Context.Context<never>,
-    readonly scope: Scope.Scope,
-    readonly idleTimeToLive: Duration.Duration | undefined,
-    readonly capacity: number
-  ) {
-    this[TypeId] = variance
-  }
-
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const make: {
-  <K, A, E, R>(options: {
-    readonly lookup: (key: K) => Effect<A, E, R>
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-    readonly capacity?: undefined
-  }): Effect<RcMap.RcMap<K, A, E>, never, Scope.Scope | R>
-  <K, A, E, R>(options: {
-    readonly lookup: (key: K) => Effect<A, E, R>
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-    readonly capacity: number
-  }): Effect<RcMap.RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>
-} = <K, A, E, R>(options: {
-  readonly lookup: (key: K) => Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
-  readonly capacity?: number | undefined
-}) =>
-  core.withFiberRuntime<RcMap.RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
-    const context = fiber.getFiberRef(core.currentContext) as Context.Context<R | Scope.Scope>
-    const scope = Context.get(context, fiberRuntime.scopeTag)
-    const self = new RcMapImpl<K, A, E>(
-      options.lookup as any,
-      context,
-      scope,
-      options.idleTimeToLive ? Duration.decode(options.idleTimeToLive) : undefined,
-      Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
-    )
-    return core.as(
-      scope.addFinalizer(() =>
-        core.suspend(() => {
-          if (self.state._tag === "Closed") {
-            return core.void
-          }
-          const map = self.state.map
-          self.state = { _tag: "Closed" }
-          return core.forEachSequentialDiscard(
-            map,
-            ([, entry]) => core.scopeClose(entry.scope, core.exitVoid)
-          ).pipe(
-            core.tap(() => {
-              MutableHashMap.clear(map)
-            }),
-            self.semaphore.withPermits(1)
-          )
-        })
-      ),
-      self
-    )
-  })
-
-/** @internal */
-export const get: {
-  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<A, E, Scope.Scope>
-  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope>
-} = dual(2, <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope> => {
-  const self = self_ as RcMapImpl<K, A, E>
-  return core.uninterruptibleMask((restore) => getImpl(self, key, restore as any))
-})
-
-const getImpl = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key: K, restore: <A>(a: A) => A) {
-  if (self.state._tag === "Closed") {
-    return yield* core.interrupt
-  }
-  const state = self.state
-  const o = MutableHashMap.get(state.map, key)
-  let entry: State.Entry<A, E>
-  if (o._tag === "Some") {
-    entry = o.value
-    entry.refCount++
-  } else if (Number.isFinite(self.capacity) && MutableHashMap.size(self.state.map) >= self.capacity) {
-    return yield* core.fail(
-      new core.ExceededCapacityException(`RcMap attempted to exceed capacity of ${self.capacity}`)
-    ) as Effect<never>
-  } else {
-    entry = yield* self.semaphore.withPermits(1)(acquire(self, key, restore))
-  }
-  const scope = yield* fiberRuntime.scopeTag
-  yield* scope.addFinalizer(() => entry.finalizer)
-  return yield* restore(core.deferredAwait(entry.deferred))
-})
-
-const acquire = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key: K, restore: <A>(a: A) => A) {
-  const scope = yield* fiberRuntime.scopeMake()
-  const deferred = yield* core.deferredMake<A, E>()
-  const acquire = self.lookup(key)
-  const contextMap = new Map(self.context.unsafeMap)
-  yield* restore(core.mapInputContext(
-    acquire as Effect<A, E>,
-    (inputContext: Context.Context<never>) => {
-      inputContext.unsafeMap.forEach((value, key) => {
-        contextMap.set(key, value)
-      })
-      contextMap.set(fiberRuntime.scopeTag.key, scope)
-      return Context.unsafeMake(contextMap)
-    }
-  )).pipe(
-    core.exit,
-    core.flatMap((exit) => core.deferredDone(deferred, exit)),
-    circular.forkIn(scope)
-  )
-  const entry: State.Entry<A, E> = {
-    deferred,
-    scope,
-    finalizer: undefined as any,
-    fiber: undefined,
-    expiresAt: 0,
-    refCount: 1
-  }
-  ;(entry as any).finalizer = release(self, key, entry)
-  if (self.state._tag === "Open") {
-    MutableHashMap.set(self.state.map, key, entry)
-  }
-  return entry
-})
-
-const release = <K, A, E>(self: RcMapImpl<K, A, E>, key: K, entry: State.Entry<A, E>) =>
-  coreEffect.clockWith((clock) => {
-    entry.refCount--
-    if (entry.refCount > 0) {
-      return core.void
-    } else if (
-      self.state._tag === "Closed"
-      || !MutableHashMap.has(self.state.map, key)
-      || self.idleTimeToLive === undefined
-    ) {
-      if (self.state._tag === "Open") {
-        MutableHashMap.remove(self.state.map, key)
-      }
-      return core.scopeClose(entry.scope, core.exitVoid)
-    }
-
-    if (!Duration.isFinite(self.idleTimeToLive)) {
-      return core.void
-    }
-
-    entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
-    if (entry.fiber) return core.void
-
-    return core.interruptibleMask(function loop(restore): Effect<void> {
-      const now = clock.unsafeCurrentTimeMillis()
-      const remaining = entry.expiresAt - now
-      if (remaining <= 0) {
-        if (self.state._tag === "Closed" || entry.refCount > 0) return core.void
-        MutableHashMap.remove(self.state.map, key)
-        return restore(core.scopeClose(entry.scope, core.exitVoid))
-      }
-      return core.flatMap(clock.sleep(Duration.millis(remaining)), () => loop(restore))
-    }).pipe(
-      fiberRuntime.ensuring(core.sync(() => {
-        entry.fiber = undefined
-      })),
-      circular.forkIn(self.scope),
-      core.tap((fiber) => {
-        entry.fiber = fiber
-      }),
-      self.semaphore.withPermits(1)
-    )
-  })
-
-/** @internal */
-export const keys = <K, A, E>(self: RcMap.RcMap<K, A, E>): Effect<Array<K>> => {
-  const impl = self as RcMapImpl<K, A, E>
-  return core.suspend(() =>
-    impl.state._tag === "Closed" ? core.interrupt : core.succeed(MutableHashMap.keys(impl.state.map))
-  )
-}
-
-/** @internal */
-export const invalidate: {
-  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<void>
-  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<void>
-} = dual(
-  2,
-  core.fnUntraced(function*<K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K) {
-    const self = self_ as RcMapImpl<K, A, E>
-    if (self.state._tag === "Closed") return
-    const o = MutableHashMap.get(self.state.map, key)
-    if (o._tag === "None") return
-    const entry = o.value
-    MutableHashMap.remove(self.state.map, key)
-    if (entry.refCount > 0) return
-    yield* core.scopeClose(entry.scope, core.exitVoid)
-    if (entry.fiber) yield* core.interruptFiber(entry.fiber)
-  })
-)
-
-/** @internal */
-export const has: {
-  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<boolean>
-  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<boolean>
-} = dual(2, <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K): Effect<boolean> => {
-  const self = self_ as RcMapImpl<K, A, E>
-  return core.sync(() => {
-    if (self.state._tag === "Closed") return false
-    return MutableHashMap.has(self.state.map, key)
-  })
-})
-
-/** @internal */
-export const touch: {
-  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<void>
-  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<void>
-} = dual(
-  2,
-  <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K) =>
-    coreEffect.clockWith((clock) => {
-      const self = self_ as RcMapImpl<K, A, E>
-      if (!self.idleTimeToLive || self.state._tag === "Closed") return core.void
-      const o = MutableHashMap.get(self.state.map, key)
-      if (o._tag === "None") return core.void
-      o.value.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
-      return core.void
-    })
-)