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

package/src/internal/stm/tSet.ts

@@ -0,0 +1,259 @@
+import * as RA from "../../Array.js"
+import * as Chunk from "../../Chunk.js"
+import { dual, pipe } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import type * as Option from "../../Option.js"
+import { hasProperty, type Predicate } from "../../Predicate.js"
+import * as STM from "../../STM.js"
+import type * as TMap from "../../TMap.js"
+import type * as TSet from "../../TSet.js"
+import * as core from "./core.js"
+import * as tMap from "./tMap.js"
+
+/** @internal */
+const TSetSymbolKey = "effect/TSet"
+
+/** @internal */
+export const TSetTypeId: TSet.TSetTypeId = Symbol.for(
+  TSetSymbolKey
+) as TSet.TSetTypeId
+
+const tSetVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+/** @internal */
+class TSetImpl<in out A> implements TSet.TSet<A> {
+  readonly [TSetTypeId] = tSetVariance
+  constructor(readonly tMap: TMap.TMap<A, void>) {}
+}
+
+const isTSet = (u: unknown) => hasProperty(u, TSetTypeId)
+
+/** @internal */
+export const add = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
+>(2, (self, value) => tMap.set(self.tMap, value, void 0 as void))
+
+/** @internal */
+export const difference = dual<
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
+>(2, (self, other) =>
+  core.flatMap(
+    toHashSet(other),
+    (values) => removeIf(self, (value) => HashSet.has(values, value), { discard: true })
+  ))
+
+/** @internal */
+export const empty = <A>(): STM.STM<TSet.TSet<A>> => fromIterable<A>([])
+
+/** @internal */
+export const forEach = dual<
+  <A, R, E>(f: (value: A) => STM.STM<void, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
+  <A, R, E>(self: TSet.TSet<A>, f: (value: A) => STM.STM<void, E, R>) => STM.STM<void, E, R>
+>(2, (self, f) => reduceSTM(self, void 0 as void, (_, value) => f(value)))
+
+/** @internal */
+export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<TSet.TSet<A>> =>
+  core.map(
+    tMap.fromIterable(Array.from(iterable).map((a): [A, void] => [a, void 0])),
+    (tMap) => new TSetImpl(tMap)
+  )
+
+/** @internal */
+export const has = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<boolean>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<boolean>
+>(2, (self, value) => tMap.has(self.tMap, value))
+
+/** @internal */
+export const intersection = dual<
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
+>(2, (self, other) =>
+  core.flatMap(
+    toHashSet(other),
+    (values) => pipe(self, retainIf((value) => pipe(values, HashSet.has(value)), { discard: true }))
+  ))
+
+/** @internal */
+export const isEmpty = <A>(self: TSet.TSet<A>): STM.STM<boolean> => tMap.isEmpty(self.tMap)
+
+/** @internal */
+export const make = <Elements extends Array<any>>(
+  ...elements: Elements
+): STM.STM<TSet.TSet<Elements[number]>> => fromIterable(elements)
+
+/** @internal */
+export const reduce = dual<
+  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: TSet.TSet<A>) => STM.STM<Z>,
+  <Z, A>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => STM.STM<Z>
+>(3, (self, zero, f) =>
+  tMap.reduce(
+    self.tMap,
+    zero,
+    (acc, _, key) => f(acc, key)
+  ))
+
+/** @internal */
+export const reduceSTM = dual<
+  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => (self: TSet.TSet<A>) => STM.STM<Z, E, R>,
+  <Z, A, R, E>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => STM.STM<Z, E, R>
+>(3, (self, zero, f) =>
+  tMap.reduceSTM(
+    self.tMap,
+    zero,
+    (acc, _, key) => f(acc, key)
+  ))
+
+/** @internal */
+export const remove = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
+>(2, (self, value) => tMap.remove(self.tMap, value))
+
+/** @internal */
+export const removeAll = dual<
+  <A>(iterable: Iterable<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, iterable: Iterable<A>) => STM.STM<void>
+>(2, (self, iterable) => tMap.removeAll(self.tMap, iterable))
+
+/** @internal */
+export const removeIf: {
+  <A>(predicate: Predicate<A>, options: {
+    readonly discard: true
+  }): (self: TSet.TSet<A>) => STM.STM<void>
+  <A>(
+    predicate: Predicate<A>,
+    options?: {
+      readonly discard: false
+    }
+  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
+    readonly discard: true
+  }): STM.STM<void>
+  <A>(
+    self: TSet.TSet<A>,
+    predicate: Predicate<A>,
+    options?: {
+      readonly discard: false
+    }
+  ): STM.STM<Array<A>>
+} = dual(
+  (args) => isTSet(args[0]),
+  (self, predicate, options) =>
+    options?.discard === true ? tMap.removeIf(self.tMap, (key) => predicate(key), { discard: true }) : pipe(
+      tMap.removeIf(self.tMap, (key) => predicate(key)),
+      core.map(RA.map((entry) => entry[0]))
+    )
+)
+
+/** @internal */
+export const retainIf: {
+  <A>(predicate: Predicate<A>, options: {
+    readonly discard: true
+  }): (self: TSet.TSet<A>) => STM.STM<void>
+  <A>(
+    predicate: Predicate<A>,
+    options?: {
+      readonly discard: false
+    }
+  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
+    readonly discard: true
+  }): STM.STM<void>
+  <A>(
+    self: TSet.TSet<A>,
+    predicate: Predicate<A>,
+    options?: {
+      readonly discard: false
+    }
+  ): STM.STM<Array<A>>
+} = dual((args) => isTSet(args[0]), (self, predicate, options) =>
+  options?.discard === true ?
+    tMap.retainIf(self.tMap, (key) => predicate(key), { discard: true }) :
+    pipe(
+      tMap.retainIf(self.tMap, (key) => predicate(key)),
+      core.map(RA.map((entry) => entry[0]))
+    ))
+
+/** @internal */
+export const size = <A>(self: TSet.TSet<A>): STM.STM<number> => core.map(toChunk(self), (chunk) => chunk.length)
+
+/** @internal */
+export const takeFirst = dual<
+  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<B>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<B>
+>(2, (self, pf) => tMap.takeFirst(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const takeFirstSTM = dual<
+  <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => (self: TSet.TSet<A>) => STM.STM<B, E, R>,
+  <A, B, E, R>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => STM.STM<B, E, R>
+>(2, (self, pf) => tMap.takeFirstSTM(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const takeSome = dual<
+  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<RA.NonEmptyArray<B>>
+>(2, (self, pf) => tMap.takeSome(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const takeSomeSTM = dual<
+  <A, B, E, R>(
+    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
+  ) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>, E, R>,
+  <A, B, E, R>(
+    self: TSet.TSet<A>,
+    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
+  ) => STM.STM<RA.NonEmptyArray<B>, E, R>
+>(2, (self, pf) => tMap.takeSomeSTM(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const toChunk = <A>(self: TSet.TSet<A>): STM.STM<Chunk.Chunk<A>> =>
+  tMap.keys(self.tMap).pipe(STM.map(Chunk.unsafeFromArray))
+
+/** @internal */
+export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<HashSet.HashSet<A>> =>
+  reduce(
+    self,
+    HashSet.empty<A>(),
+    (acc, value) => pipe(acc, HashSet.add(value))
+  )
+
+/** @internal */
+export const toArray = <A>(self: TSet.TSet<A>): STM.STM<Array<A>> =>
+  reduce<Array<A>, A>(
+    self,
+    [],
+    (acc, value) => [...acc, value]
+  )
+
+/** @internal */
+export const toReadonlySet = <A>(self: TSet.TSet<A>): STM.STM<ReadonlySet<A>> =>
+  core.map(toArray(self), (values) => new Set(values))
+
+/** @internal */
+export const transform = dual<
+  <A>(f: (a: A) => A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, f: (a: A) => A) => STM.STM<void>
+>(2, (self, f) => tMap.transform(self.tMap, (key, value) => [f(key), value]))
+
+/** @internal */
+export const transformSTM = dual<
+  <A, R, E>(f: (a: A) => STM.STM<A, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
+  <A, R, E>(self: TSet.TSet<A>, f: (a: A) => STM.STM<A, E, R>) => STM.STM<void, E, R>
+>(2, (self, f) =>
+  tMap.transformSTM(
+    self.tMap,
+    (key, value) => core.map(f(key), (a) => [a, value])
+  ))
+
+/** @internal */
+export const union = dual<
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
+>(2, (self, other) => forEach(other, (value) => add(self, value)))

package/src/internal/stm/tSubscriptionRef.ts

@@ -0,0 +1,286 @@
+import * as Effect from "../../Effect.js"
+import { dual, pipe } from "../../Function.js"
+import * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import * as STM from "../../STM.js"
+import * as TPubSub from "../../TPubSub.js"
+import * as TQueue from "../../TQueue.js"
+import * as TRef from "../../TRef.js"
+import type * as TSubscriptionRef from "../../TSubscriptionRef.js"
+import * as stream from "../stream.js"
+import { tDequeueVariance } from "./tQueue.js"
+import { tRefVariance } from "./tRef.js"
+
+/** @internal */
+const TSubscriptionRefSymbolKey = "effect/TSubscriptionRef"
+
+/** @internal */
+export const TSubscriptionRefTypeId: TSubscriptionRef.TSubscriptionRefTypeId = Symbol.for(
+  TSubscriptionRefSymbolKey
+) as TSubscriptionRef.TSubscriptionRefTypeId
+
+const TSubscriptionRefVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+class TDequeueMerge<A> implements TQueue.TDequeue<A> {
+  [TQueue.TDequeueTypeId] = tDequeueVariance
+
+  constructor(
+    readonly first: TQueue.TDequeue<A>,
+    readonly second: TQueue.TDequeue<A>
+  ) {}
+
+  peek: STM.STM<A> = STM.gen(this, function*() {
+    const first = yield* this.peekOption
+    if (first._tag === "Some") {
+      return first.value
+    }
+    return yield* STM.retry
+  })
+
+  peekOption: STM.STM<Option.Option<A>> = STM.gen(this, function*() {
+    const first = yield* this.first.peekOption
+    if (first._tag === "Some") {
+      return first
+    }
+    const second = yield* this.second.peekOption
+    if (second._tag === "Some") {
+      return second
+    }
+    return Option.none()
+  })
+
+  take: STM.STM<A> = STM.gen(this, function*() {
+    if (!(yield* this.first.isEmpty)) {
+      return yield* this.first.take
+    }
+    if (!(yield* this.second.isEmpty)) {
+      return yield* this.second.take
+    }
+    return yield* STM.retry
+  })
+
+  takeAll: STM.STM<Array<A>> = STM.gen(this, function*() {
+    return [...yield* this.first.takeAll, ...yield* this.second.takeAll]
+  })
+
+  takeUpTo(max: number): STM.STM<Array<A>> {
+    return STM.gen(this, function*() {
+      const first = yield* this.first.takeUpTo(max)
+      if (first.length >= max) {
+        return first
+      }
+      return [...first, ...yield* this.second.takeUpTo(max - first.length)]
+    })
+  }
+
+  capacity(): number {
+    return this.first.capacity() + this.second.capacity()
+  }
+
+  size: STM.STM<number> = STM.gen(this, function*() {
+    return (yield* this.first.size) + (yield* this.second.size)
+  })
+
+  isFull: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isFull) && (yield* this.second.isFull)
+  })
+
+  isEmpty: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isEmpty) && (yield* this.second.isEmpty)
+  })
+
+  shutdown: STM.STM<void> = STM.gen(this, function*() {
+    yield* this.first.shutdown
+    yield* this.second.shutdown
+  })
+
+  isShutdown: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isShutdown) && (yield* this.second.isShutdown)
+  })
+
+  awaitShutdown: STM.STM<void> = STM.gen(this, function*() {
+    yield* this.first.awaitShutdown
+    yield* this.second.awaitShutdown
+  })
+}
+
+/** @internal */
+class TSubscriptionRefImpl<in out A> implements TSubscriptionRef.TSubscriptionRef<A> {
+  readonly [TSubscriptionRefTypeId] = TSubscriptionRefVariance
+  readonly [TRef.TRefTypeId] = tRefVariance
+
+  constructor(
+    readonly ref: TRef.TRef<A>,
+    readonly pubsub: TPubSub.TPubSub<A>
+  ) {}
+
+  get todos() {
+    return this.ref.todos
+  }
+
+  get versioned() {
+    return this.ref.versioned
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+
+  get changes(): STM.STM<TQueue.TDequeue<A>> {
+    return STM.gen(this, function*() {
+      const first = yield* TQueue.unbounded<A>()
+      yield* TQueue.offer(first, yield* TRef.get(this.ref))
+      return new TDequeueMerge(first, yield* TPubSub.subscribe(this.pubsub))
+    })
+  }
+
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B> {
+    return pipe(
+      TRef.get(this.ref),
+      STM.map(f),
+      STM.flatMap(([b, a]) =>
+        pipe(
+          TRef.set(this.ref, a),
+          STM.as(b),
+          STM.zipLeft(TPubSub.publish(this.pubsub, a))
+        )
+      )
+    )
+  }
+}
+
+/** @internal */
+export const make = <A>(value: A): STM.STM<TSubscriptionRef.TSubscriptionRef<A>> =>
+  pipe(
+    STM.all([
+      TPubSub.unbounded<A>(),
+      TRef.make(value)
+    ]),
+    STM.map(([pubsub, ref]) => new TSubscriptionRefImpl(ref, pubsub))
+  )
+
+/** @internal */
+export const get = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) => TRef.get(self.ref)
+
+/** @internal */
+export const set = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<void>
+>(
+  2,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A): STM.STM<void> =>
+    self.modify((): [void, A] => [void 0, value])
+)
+
+/** @internal */
+export const getAndSet = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
+>(2, (self, value) => self.modify((a) => [a, value]))
+
+/** @internal */
+export const getAndUpdate = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
+>(2, (self, f) => self.modify((a) => [a, f(a)]))
+
+/** @internal */
+export const getAndUpdateSome = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
+>(2, (self, f) =>
+  self.modify((a) =>
+    Option.match(f(a), {
+      onNone: () => [a, a],
+      onSome: (b) => [a, b]
+    })
+  ))
+
+/** @internal */
+export const setAndGet = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
+>(2, (self, value) => self.modify(() => [value, value]))
+
+/** @internal */
+export const modify = dual<
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
+  <A, B>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<B>
+>(2, (self, f) => self.modify(f))
+
+/** @internal */
+export const modifySome = dual<
+  <A, B>(
+    fallback: B,
+    f: (a: A) => Option.Option<readonly [B, A]>
+  ) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
+  <A, B>(
+    self: TSubscriptionRef.TSubscriptionRef<A>,
+    fallback: B,
+    f: (a: A) => Option.Option<readonly [B, A]>
+  ) => STM.STM<B>
+>(3, (self, fallback, f) =>
+  self.modify((a) =>
+    Option.match(f(a), {
+      onNone: () => [fallback, a],
+      onSome: (b) => b
+    })
+  ))
+
+/** @internal */
+export const update = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<void>
+>(2, (self, f) => self.modify((a) => [void 0, f(a)]))
+
+/** @internal */
+export const updateAndGet = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
+>(2, (self, f) =>
+  self.modify((a) => {
+    const b = f(a)
+    return [b, b]
+  }))
+
+/** @internal */
+export const updateSome = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<void>
+>(
+  2,
+  (self, f) =>
+    self.modify((a) => [
+      void 0,
+      Option.match(f(a), {
+        onNone: () => a,
+        onSome: (b) => b
+      })
+    ])
+)
+
+/** @internal */
+export const updateSomeAndGet = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
+>(
+  2,
+  (self, f) =>
+    self.modify((a) =>
+      Option.match(f(a), {
+        onNone: () => [a, a],
+        onSome: (b) => [b, b]
+      })
+    )
+)
+
+/** @internal */
+export const changesScoped = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
+  Effect.acquireRelease(self.changes, TQueue.shutdown)
+
+/** @internal */
+export const changesStream = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
+  stream.unwrap(Effect.map(self.changes, stream.fromTQueue))

package/src/internal/stm/tryCommit.ts

@@ -0,0 +1,34 @@
+import type * as Exit from "../../Exit.js"
+import type * as Journal from "./journal.js"
+import * as OpCodes from "./opCodes/tryCommit.js"
+
+/** @internal */
+export type TryCommit<A, E = never> = Done<A, E> | Suspend
+
+/** @internal */
+export interface Done<out A, out E> {
+  readonly _tag: OpCodes.OP_DONE
+  readonly exit: Exit.Exit<A, E>
+}
+
+/** @internal */
+export interface Suspend {
+  readonly _tag: OpCodes.OP_SUSPEND
+  readonly journal: Journal.Journal
+}
+
+/** @internal */
+export const done = <A, E>(exit: Exit.Exit<A, E>): TryCommit<A, E> => {
+  return {
+    _tag: OpCodes.OP_DONE,
+    exit
+  }
+}
+
+/** @internal */
+export const suspend = (journal: Journal.Journal): TryCommit<never> => {
+  return {
+    _tag: OpCodes.OP_SUSPEND,
+    journal
+  }
+}

package/src/internal/stm/txnId.ts

@@ -0,0 +1,14 @@
+/** @internal */
+export type TxnId = number & {
+  readonly TransactioId: unique symbol
+}
+
+/** @internal */
+const txnCounter = { ref: 0 }
+
+/** @internal */
+export const make = (): TxnId => {
+  const newId = txnCounter.ref + 1
+  txnCounter.ref = newId
+  return newId as TxnId
+}

package/src/internal/stm/versioned.ts

@@ -0,0 +1,4 @@
+/** @internal */
+export class Versioned<out A> {
+  constructor(readonly value: A) {}
+}

package/src/internal/stream/debounceState.ts

@@ -0,0 +1,57 @@
+import type * as Chunk from "../../Chunk.js"
+import type * as Fiber from "../../Fiber.js"
+import type * as HandoffSignal from "./handoffSignal.js"
+
+/** @internal */
+export type DebounceState<A, E = never> = NotStarted | Previous<A> | Current<A, E>
+
+/** @internal */
+export const OP_NOT_STARTED = "NotStarted" as const
+
+/** @internal */
+export type OP_NOT_STARTED = typeof OP_NOT_STARTED
+
+/** @internal */
+export const OP_PREVIOUS = "Previous" as const
+
+/** @internal */
+export type OP_PREVIOUS = typeof OP_PREVIOUS
+
+/** @internal */
+export const OP_CURRENT = "Current" as const
+
+/** @internal */
+export type OP_CURRENT = typeof OP_CURRENT
+
+export interface NotStarted {
+  readonly _tag: OP_NOT_STARTED
+}
+
+/** @internal */
+export interface Previous<out A> {
+  readonly _tag: OP_PREVIOUS
+  readonly fiber: Fiber.Fiber<Chunk.Chunk<A>>
+}
+
+/** @internal */
+export interface Current<out A, out E = never> {
+  readonly _tag: OP_CURRENT
+  readonly fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>
+}
+
+/** @internal */
+export const notStarted: DebounceState<never> = {
+  _tag: OP_NOT_STARTED
+}
+
+/** @internal */
+export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<A> => ({
+  _tag: OP_PREVIOUS,
+  fiber
+})
+
+/** @internal */
+export const current = <A, E>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>): DebounceState<A, E> => ({
+  _tag: OP_CURRENT,
+  fiber
+})