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

package/src/internal/random.ts

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

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

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