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

package/src/internal/stm/tQueue.ts

@@ -1,393 +0,0 @@
-import * as RA from "../../Array.js"
-import * as Chunk from "../../Chunk.js"
-import { dual, pipe } from "../../Function.js"
-import * as Option from "../../Option.js"
-import { hasProperty, type Predicate } from "../../Predicate.js"
-import type * as STM from "../../STM.js"
-import type * as TQueue from "../../TQueue.js"
-import type * as TRef from "../../TRef.js"
-import * as core from "./core.js"
-import * as OpCodes from "./opCodes/strategy.js"
-import * as stm from "./stm.js"
-import * as tRef from "./tRef.js"
-
-const TEnqueueSymbolKey = "effect/TQueue/TEnqueue"
-
-/** @internal */
-export const TEnqueueTypeId: TQueue.TEnqueueTypeId = Symbol.for(TEnqueueSymbolKey) as TQueue.TEnqueueTypeId
-
-const TDequeueSymbolKey = "effect/TQueue/TDequeue"
-
-/** @internal */
-export const TDequeueTypeId: TQueue.TDequeueTypeId = Symbol.for(TDequeueSymbolKey) as TQueue.TDequeueTypeId
-
-/**
- * A `Strategy` describes how the queue will handle values if the queue is at
- * capacity.
- *
- * @internal
- */
-export type TQueueStrategy = BackPressure | Dropping | Sliding
-
-/**
- * A strategy that retries if the queue is at capacity.
- *
- * @internal
- */
-export interface BackPressure {
-  readonly _tag: OpCodes.OP_BACKPRESSURE_STRATEGY
-}
-
-/**
- * A strategy that drops new values if the queue is at capacity.
- *
- * @internal
- */
-export interface Dropping {
-  readonly _tag: OpCodes.OP_DROPPING_STRATEGY
-}
-
-/**
- * A strategy that drops old values if the queue is at capacity.
- *
- * @internal
- */
-export interface Sliding {
-  readonly _tag: OpCodes.OP_SLIDING_STRATEGY
-}
-
-/** @internal */
-export const BackPressure: TQueueStrategy = {
-  _tag: OpCodes.OP_BACKPRESSURE_STRATEGY
-}
-
-/** @internal */
-export const Dropping: TQueueStrategy = {
-  _tag: OpCodes.OP_DROPPING_STRATEGY
-}
-
-/** @internal */
-export const Sliding: TQueueStrategy = {
-  _tag: OpCodes.OP_SLIDING_STRATEGY
-}
-
-/** @internal */
-export const tDequeueVariance = {
-  /* c8 ignore next */
-  _Out: (_: never) => _
-}
-
-/** @internal */
-export const tEnqueueVariance = {
-  /* c8 ignore next */
-  _In: (_: unknown) => _
-}
-
-class TQueueImpl<in out A> implements TQueue.TQueue<A> {
-  readonly [TDequeueTypeId] = tDequeueVariance
-  readonly [TEnqueueTypeId] = tEnqueueVariance
-  constructor(
-    readonly ref: TRef.TRef<Array<A> | undefined>,
-    readonly requestedCapacity: number,
-    readonly strategy: TQueueStrategy
-  ) {}
-
-  capacity(): number {
-    return this.requestedCapacity
-  }
-
-  size: STM.STM<number> = core.withSTMRuntime((runtime) => {
-    const queue = tRef.unsafeGet(this.ref, runtime.journal)
-    if (queue === undefined) {
-      return core.interruptAs(runtime.fiberId)
-    }
-    return core.succeed(queue.length)
-  })
-
-  isFull: STM.STM<boolean> = core.map(this.size, (size) => size === this.requestedCapacity)
-
-  isEmpty: STM.STM<boolean> = core.map(this.size, (size) => size === 0)
-
-  shutdown: STM.STM<void> = core.withSTMRuntime((runtime) => {
-    tRef.unsafeSet(this.ref, void 0, runtime.journal)
-    return stm.void
-  })
-
-  isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
-    const queue = tRef.unsafeGet(this.ref, journal)
-    return queue === undefined
-  })
-
-  awaitShutdown: STM.STM<void> = core.flatMap(
-    this.isShutdown,
-    (isShutdown) => isShutdown ? stm.void : core.retry
-  )
-
-  offer(value: A): STM.STM<boolean> {
-    return core.withSTMRuntime((runtime) => {
-      const queue = pipe(this.ref, tRef.unsafeGet(runtime.journal))
-      if (queue === undefined) {
-        return core.interruptAs(runtime.fiberId)
-      }
-      if (queue.length < this.requestedCapacity) {
-        queue.push(value)
-        tRef.unsafeSet(this.ref, queue, runtime.journal)
-        return core.succeed(true)
-      }
-      switch (this.strategy._tag) {
-        case OpCodes.OP_BACKPRESSURE_STRATEGY: {
-          return core.retry
-        }
-        case OpCodes.OP_DROPPING_STRATEGY: {
-          return core.succeed(false)
-        }
-        case OpCodes.OP_SLIDING_STRATEGY: {
-          if (queue.length === 0) {
-            return core.succeed(true)
-          }
-          queue.shift()
-          queue.push(value)
-          tRef.unsafeSet(this.ref, queue, runtime.journal)
-          return core.succeed(true)
-        }
-      }
-    })
-  }
-
-  offerAll(iterable: Iterable<A>): STM.STM<boolean> {
-    return core.withSTMRuntime((runtime) => {
-      const as = Array.from(iterable)
-      const queue = tRef.unsafeGet(this.ref, runtime.journal)
-      if (queue === undefined) {
-        return core.interruptAs(runtime.fiberId)
-      }
-      if (queue.length + as.length <= this.requestedCapacity) {
-        tRef.unsafeSet(this.ref, [...queue, ...as], runtime.journal)
-        return core.succeed(true)
-      }
-      switch (this.strategy._tag) {
-        case OpCodes.OP_BACKPRESSURE_STRATEGY: {
-          return core.retry
-        }
-        case OpCodes.OP_DROPPING_STRATEGY: {
-          const forQueue = as.slice(0, this.requestedCapacity - queue.length)
-          tRef.unsafeSet(this.ref, [...queue, ...forQueue], runtime.journal)
-          return core.succeed(false)
-        }
-        case OpCodes.OP_SLIDING_STRATEGY: {
-          const forQueue = as.slice(0, this.requestedCapacity - queue.length)
-          const toDrop = queue.length + forQueue.length - this.requestedCapacity
-          const newQueue = queue.slice(toDrop)
-          tRef.unsafeSet(this.ref, [...newQueue, ...forQueue], runtime.journal)
-          return core.succeed(true)
-        }
-      }
-    })
-  }
-
-  peek: STM.STM<A> = core.withSTMRuntime((runtime) => {
-    const queue = tRef.unsafeGet(this.ref, runtime.journal)
-    if (queue === undefined) {
-      return core.interruptAs(runtime.fiberId)
-    }
-    if (queue.length === 0) {
-      return core.retry
-    }
-    return core.succeed(queue[0])
-  })
-
-  peekOption: STM.STM<Option.Option<A>> = core.withSTMRuntime((runtime) => {
-    const queue = tRef.unsafeGet(this.ref, runtime.journal)
-    if (queue === undefined) {
-      return core.interruptAs(runtime.fiberId)
-    }
-    return core.succeed(Option.fromNullable(queue[0]))
-  })
-
-  take: STM.STM<A> = core.withSTMRuntime((runtime) => {
-    const queue = tRef.unsafeGet(this.ref, runtime.journal)
-    if (queue === undefined) {
-      return core.interruptAs(runtime.fiberId)
-    }
-    if (queue.length === 0) {
-      return core.retry
-    }
-    const dequeued = queue.shift()!
-    tRef.unsafeSet(this.ref, queue, runtime.journal)
-    return core.succeed(dequeued)
-  })
-
-  takeAll: STM.STM<Array<A>> = core.withSTMRuntime((runtime) => {
-    const queue = tRef.unsafeGet(this.ref, runtime.journal)
-    if (queue === undefined) {
-      return core.interruptAs(runtime.fiberId)
-    }
-    tRef.unsafeSet(this.ref, [], runtime.journal)
-    return core.succeed(queue)
-  })
-
-  takeUpTo(max: number): STM.STM<Array<A>> {
-    return core.withSTMRuntime((runtime) => {
-      const queue = tRef.unsafeGet(this.ref, runtime.journal)
-      if (queue === undefined) {
-        return core.interruptAs(runtime.fiberId)
-      }
-      const [toTake, remaining] = Chunk.splitAt(Chunk.unsafeFromArray(queue), max)
-      tRef.unsafeSet<Array<A> | undefined>(this.ref, Array.from(remaining), runtime.journal)
-      return core.succeed(Array.from(toTake))
-    })
-  }
-}
-
-/** @internal */
-export const isTQueue = (u: unknown): u is TQueue.TQueue<unknown> => {
-  return isTEnqueue(u) && isTDequeue(u)
-}
-
-/** @internal */
-export const isTEnqueue = (u: unknown): u is TQueue.TEnqueue<unknown> => hasProperty(u, TEnqueueTypeId)
-
-/** @internal */
-export const isTDequeue = (u: unknown): u is TQueue.TDequeue<unknown> => hasProperty(u, TDequeueTypeId)
-
-/** @internal */
-export const awaitShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<void> => self.awaitShutdown
-
-/** @internal */
-export const bounded = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
-  makeQueue<A>(requestedCapacity, BackPressure)
-
-/** @internal */
-export const capacity = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): number => {
-  return self.capacity()
-}
-
-/** @internal */
-export const dropping = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
-  makeQueue<A>(requestedCapacity, Dropping)
-
-/** @internal */
-export const isEmpty = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isEmpty
-
-/** @internal */
-export const isFull = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isFull
-
-/** @internal */
-export const isShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<boolean> => self.isShutdown
-
-/** @internal */
-export const offer = dual<
-  <A>(value: A) => (self: TQueue.TEnqueue<A>) => STM.STM<void>,
-  <A>(self: TQueue.TEnqueue<A>, value: A) => STM.STM<void>
->(2, (self, value) => self.offer(value))
-
-/** @internal */
-export const offerAll = dual<
-  <A>(iterable: Iterable<A>) => (self: TQueue.TEnqueue<A>) => STM.STM<boolean>,
-  <A>(self: TQueue.TEnqueue<A>, iterable: Iterable<A>) => STM.STM<boolean>
->(2, (self, iterable) => self.offerAll(iterable))
-
-/** @internal */
-export const peek = <A>(self: TQueue.TDequeue<A>): STM.STM<A> => self.peek
-
-/** @internal */
-export const peekOption = <A>(self: TQueue.TDequeue<A>): STM.STM<Option.Option<A>> => self.peekOption
-
-/** @internal */
-export const poll = <A>(self: TQueue.TDequeue<A>): STM.STM<Option.Option<A>> =>
-  pipe(self.takeUpTo(1), core.map(RA.head))
-
-/** @internal */
-export const seek = dual<
-  <A>(predicate: Predicate<A>) => (self: TQueue.TDequeue<A>) => STM.STM<A>,
-  <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>) => STM.STM<A>
->(2, (self, predicate) => seekLoop(self, predicate))
-
-const seekLoop = <A>(self: TQueue.TDequeue<A>, predicate: Predicate<A>): STM.STM<A> =>
-  core.flatMap(
-    self.take,
-    (a) => predicate(a) ? core.succeed(a) : seekLoop(self, predicate)
-  )
-
-/** @internal */
-export const shutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<void> => self.shutdown
-
-/** @internal */
-export const size = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<number> => self.size
-
-/** @internal */
-export const sliding = <A>(requestedCapacity: number): STM.STM<TQueue.TQueue<A>> =>
-  makeQueue<A>(requestedCapacity, Sliding)
-
-/** @internal */
-export const take = <A>(self: TQueue.TDequeue<A>): STM.STM<A> => self.take
-
-/** @internal */
-export const takeAll = <A>(self: TQueue.TDequeue<A>): STM.STM<Array<A>> => self.takeAll
-
-/** @internal */
-export const takeBetween = dual<
-  (min: number, max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, min: number, max: number) => STM.STM<Array<A>>
->(
-  3,
-  <A>(self: TQueue.TDequeue<A>, min: number, max: number): STM.STM<Array<A>> =>
-    stm.suspend(() => {
-      const takeRemainder = (
-        min: number,
-        max: number,
-        acc: Chunk.Chunk<A>
-      ): STM.STM<Chunk.Chunk<A>> => {
-        if (max < min) {
-          return core.succeed(acc)
-        }
-        return pipe(
-          self.takeUpTo(max),
-          core.flatMap((taken) => {
-            const remaining = min - taken.length
-            if (remaining === 1) {
-              return pipe(
-                self.take,
-                core.map((a) => pipe(acc, Chunk.appendAll(Chunk.unsafeFromArray(taken)), Chunk.append(a)))
-              )
-            }
-            if (remaining > 1) {
-              return pipe(
-                self.take,
-                core.flatMap((a) =>
-                  takeRemainder(
-                    remaining - 1,
-                    max - taken.length - 1,
-                    pipe(acc, Chunk.appendAll(Chunk.unsafeFromArray(taken)), Chunk.append(a))
-                  )
-                )
-              )
-            }
-            return core.succeed(pipe(acc, Chunk.appendAll(Chunk.unsafeFromArray(taken))))
-          })
-        )
-      }
-      return core.map(takeRemainder(min, max, Chunk.empty<A>()), (c) => Array.from(c))
-    })
-)
-
-/** @internal */
-export const takeN = dual<
-  (n: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, n: number) => STM.STM<Array<A>>
->(2, (self, n) => pipe(self, takeBetween(n, n)))
-
-/** @internal */
-export const takeUpTo = dual<
-  (max: number) => <A>(self: TQueue.TDequeue<A>) => STM.STM<Array<A>>,
-  <A>(self: TQueue.TDequeue<A>, max: number) => STM.STM<Array<A>>
->(2, (self, max) => self.takeUpTo(max))
-
-/** @internal */
-export const unbounded = <A>(): STM.STM<TQueue.TQueue<A>> => makeQueue<A>(Number.MAX_SAFE_INTEGER, Dropping)
-
-const makeQueue = <A>(requestedCapacity: number, strategy: TQueueStrategy): STM.STM<TQueue.TQueue<A>> =>
-  core.map(
-    tRef.make<Array<A> | undefined>([]),
-    (ref) => new TQueueImpl<A>(ref, requestedCapacity, strategy)
-  )

package/src/internal/stm/tRandom.ts

@@ -1,140 +0,0 @@
-import * as Context from "../../Context.js"
-import { pipe } from "../../Function.js"
-import * as Layer from "../../Layer.js"
-import type * as STM from "../../STM.js"
-import type * as TArray from "../../TArray.js"
-import type * as TRandom from "../../TRandom.js"
-import type * as TRef from "../../TRef.js"
-import * as Random from "../../Utils.js"
-import * as core from "./core.js"
-import * as stm from "./stm.js"
-import * as tArray from "./tArray.js"
-import * as tRef from "./tRef.js"
-
-const TRandomSymbolKey = "effect/TRandom"
-
-/** @internal */
-export const TRandomTypeId: TRandom.TRandomTypeId = Symbol.for(
-  TRandomSymbolKey
-) as TRandom.TRandomTypeId
-
-const randomInteger = (state: Random.PCGRandomState): [number, Random.PCGRandomState] => {
-  const prng = new Random.PCGRandom()
-  prng.setState(state)
-  return [prng.integer(0), prng.getState()]
-}
-
-const randomIntegerBetween = (low: number, high: number) => {
-  return (state: Random.PCGRandomState): [number, Random.PCGRandomState] => {
-    const prng = new Random.PCGRandom()
-    prng.setState(state)
-    return [prng.integer(high - low) + low, prng.getState()]
-  }
-}
-
-const randomNumber = (state: Random.PCGRandomState): [number, Random.PCGRandomState] => {
-  const prng = new Random.PCGRandom()
-  prng.setState(state)
-  return [prng.number(), prng.getState()]
-}
-
-const withState = <A>(
-  state: TRef.TRef<Random.PCGRandomState>,
-  f: (state: Random.PCGRandomState) => [A, Random.PCGRandomState]
-): STM.STM<A> => {
-  return pipe(state, tRef.modify(f))
-}
-
-const shuffleWith = <A>(
-  iterable: Iterable<A>,
-  nextIntBounded: (n: number) => STM.STM<number>
-): STM.STM<Array<A>> => {
-  const swap = (buffer: TArray.TArray<A>, index1: number, index2: number): STM.STM<void> =>
-    pipe(
-      buffer,
-      tArray.get(index1),
-      core.flatMap((tmp) =>
-        pipe(
-          buffer,
-          tArray.updateSTM(index1, () => pipe(buffer, tArray.get(index2))),
-          core.zipRight(
-            pipe(
-              buffer,
-              tArray.update(index2, () => tmp)
-            )
-          )
-        )
-      )
-    )
-  return pipe(
-    tArray.fromIterable(iterable),
-    core.flatMap((buffer) => {
-      const array: Array<number> = []
-      for (let i = array.length; i >= 2; i = i - 1) {
-        array.push(i)
-      }
-      return pipe(
-        array,
-        stm.forEach((n) => pipe(nextIntBounded(n), core.flatMap((k) => swap(buffer, n - 1, k))), { discard: true }),
-        core.zipRight(tArray.toArray(buffer))
-      )
-    })
-  )
-}
-
-/** @internal */
-export const Tag = Context.GenericTag<TRandom.TRandom>("effect/TRandom")
-
-class TRandomImpl implements TRandom.TRandom {
-  readonly [TRandomTypeId]: TRandom.TRandomTypeId = TRandomTypeId
-  constructor(readonly state: TRef.TRef<Random.PCGRandomState>) {
-    this.next = withState(this.state, randomNumber)
-    this.nextBoolean = core.flatMap(this.next, (n) => core.succeed(n > 0.5))
-    this.nextInt = withState(this.state, randomInteger)
-  }
-
-  next: STM.STM<number>
-  nextBoolean: STM.STM<boolean>
-  nextInt: STM.STM<number>
-
-  nextRange(min: number, max: number): STM.STM<number> {
-    return core.flatMap(this.next, (n) => core.succeed((max - min) * n + min))
-  }
-  nextIntBetween(low: number, high: number): STM.STM<number> {
-    return withState(this.state, randomIntegerBetween(low, high))
-  }
-  shuffle<A>(elements: Iterable<A>): STM.STM<Array<A>> {
-    return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
-  }
-}
-
-/** @internal */
-export const live: Layer.Layer<TRandom.TRandom> = Layer.effect(
-  Tag,
-  pipe(
-    tRef.make(new Random.PCGRandom((Math.random() * 4294967296) >>> 0).getState()),
-    core.map((seed) => new TRandomImpl(seed)),
-    core.commit
-  )
-)
-
-/** @internal */
-export const next: STM.STM<number, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.next)
-
-/** @internal */
-export const nextBoolean: STM.STM<boolean, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.nextBoolean)
-
-/** @internal */
-export const nextInt: STM.STM<number, never, TRandom.TRandom> = core.flatMap(Tag, (random) => random.nextInt)
-
-/** @internal */
-export const nextIntBetween = (low: number, high: number): STM.STM<number, never, TRandom.TRandom> =>
-  core.flatMap(Tag, (random) => random.nextIntBetween(low, high))
-
-/** @internal */
-export const nextRange = (min: number, max: number): STM.STM<number, never, TRandom.TRandom> =>
-  core.flatMap(Tag, (random) => random.nextRange(min, max))
-
-/** @internal */
-export const shuffle = <A>(elements: Iterable<A>): STM.STM<Array<A>, never, TRandom.TRandom> =>
-  core.flatMap(Tag, (random) => random.shuffle(elements))