effect 2.0.0-next.44 → 2.0.0-next.46

package/src/internal/stm/tSet.ts

@@ -0,0 +1,237 @@
+import { dual, pipe } from "../../Function"
+import * as HashSet from "../../HashSet"
+import * as core from "../../internal/stm/core"
+import * as tMap from "../../internal/stm/tMap"
+import type * as Option from "../../Option"
+import type { Predicate } from "../../Predicate"
+import * as RA from "../../ReadonlyArray"
+import type * as STM from "../../STM"
+import type * as TMap from "../../TMap"
+import type * as TSet from "../../TSet"
+
+/** @internal */
+const TSetSymbolKey = "effect/TSet"
+
+/** @internal */
+export const TSetTypeId: TSet.TSetTypeId = Symbol.for(
+  TSetSymbolKey
+) as TSet.TSetTypeId
+
+/** @internal */
+const tSetVariance = {
+  _A: (_: never) => _
+}
+
+/** @internal */
+class TSetImpl<A> implements TSet.TSet<A> {
+  readonly [TSetTypeId] = tSetVariance
+  constructor(readonly tMap: TMap.TMap<A, void>) {}
+}
+
+/** @internal */
+export const add = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, 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<never, never, void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+>(2, (self, other) =>
+  core.flatMap(
+    toHashSet(other),
+    (values) => removeIfDiscard(self, (value) => HashSet.has(values, value))
+  ))
+
+/** @internal */
+export const empty = <A>(): STM.STM<never, never, TSet.TSet<A>> => fromIterable([])
+
+/** @internal */
+export const forEach = dual<
+  <A, R, E>(f: (value: A) => STM.STM<R, E, void>) => (self: TSet.TSet<A>) => STM.STM<R, E, void>,
+  <A, R, E>(self: TSet.TSet<A>, f: (value: A) => STM.STM<R, E, void>) => STM.STM<R, E, void>
+>(2, (self, f) => reduceSTM(self, void 0 as void, (_, value) => f(value)))
+
+/** @internal */
+export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<never, never, TSet.TSet<A>> =>
+  core.map(
+    tMap.fromIterable(Array.from(iterable).map((a) => [a, void 0])),
+    (tMap) => new TSetImpl(tMap)
+  )
+
+/** @internal */
+export const has = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, boolean>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, 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<never, never, void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+>(2, (self, other) =>
+  core.flatMap(
+    toHashSet(other),
+    (values) => pipe(self, retainIfDiscard((value) => pipe(values, HashSet.has(value))))
+  ))
+
+/** @internal */
+export const isEmpty = <A>(self: TSet.TSet<A>): STM.STM<never, never, boolean> => tMap.isEmpty(self.tMap)
+
+/** @internal */
+export const make = <Elements extends Array<any>>(
+  ...elements: Elements
+): STM.STM<never, never, 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<never, never, Z>,
+  <Z, A>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => STM.STM<never, never, Z>
+>(3, (self, zero, f) =>
+  tMap.reduceWithIndex(
+    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<R, E, Z>) => (self: TSet.TSet<A>) => STM.STM<R, E, Z>,
+  <Z, A, R, E>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<R, E, Z>) => STM.STM<R, E, Z>
+>(3, (self, zero, f) =>
+  tMap.reduceWithIndexSTM(
+    self.tMap,
+    zero,
+    (acc, _, key) => f(acc, key)
+  ))
+
+/** @internal */
+export const remove = dual<
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, void>
+>(2, (self, value) => tMap.remove(self.tMap, value))
+
+/** @internal */
+export const removeAll = dual<
+  <A>(iterable: Iterable<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, iterable: Iterable<A>) => STM.STM<never, never, void>
+>(2, (self, iterable) => tMap.removeAll(self.tMap, iterable))
+
+/** @internal */
+export const removeIf = dual<
+  <A>(predicate: Predicate<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, Array<A>>,
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>) => STM.STM<never, never, Array<A>>
+>(2, (self, predicate) =>
+  pipe(
+    tMap.removeIf(self.tMap, (key) => predicate(key)),
+    core.map(RA.map((entry) => entry[0]))
+  ))
+
+/** @internal */
+export const removeIfDiscard = dual<
+  <A>(predicate: Predicate<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>) => STM.STM<never, never, void>
+>(2, (self, predicate) =>
+  tMap.removeIfDiscard(
+    self.tMap,
+    (key) => predicate(key)
+  ))
+
+/** @internal */
+export const retainIf = dual<
+  <A>(predicate: Predicate<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, Array<A>>,
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>) => STM.STM<never, never, Array<A>>
+>(2, (self, predicate) =>
+  pipe(
+    tMap.retainIf(self.tMap, (key) => predicate(key)),
+    core.map(RA.map((entry) => entry[0]))
+  ))
+
+/** @internal */
+export const retainIfDiscard = dual<
+  <A>(predicate: Predicate<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, predicate: Predicate<A>) => STM.STM<never, never, void>
+>(2, (self, predicate) =>
+  tMap.retainIfDiscard(
+    self.tMap,
+    (key) => predicate(key)
+  ))
+
+/** @internal */
+export const size = <A>(self: TSet.TSet<A>): STM.STM<never, never, 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<never, never, B>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<never, never, B>
+>(2, (self, pf) => tMap.takeFirst(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const takeFirstSTM = dual<
+  <A, R, E, B>(pf: (a: A) => STM.STM<R, Option.Option<E>, B>) => (self: TSet.TSet<A>) => STM.STM<R, E, B>,
+  <A, R, E, B>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<R, Option.Option<E>, B>) => STM.STM<R, E, B>
+>(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<never, never, RA.NonEmptyArray<B>>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<never, never, RA.NonEmptyArray<B>>
+>(2, (self, pf) => tMap.takeSome(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const takeSomeSTM = dual<
+  <A, R, E, B>(
+    pf: (a: A) => STM.STM<R, Option.Option<E>, B>
+  ) => (self: TSet.TSet<A>) => STM.STM<R, E, RA.NonEmptyArray<B>>,
+  <A, R, E, B>(
+    self: TSet.TSet<A>,
+    pf: (a: A) => STM.STM<R, Option.Option<E>, B>
+  ) => STM.STM<R, E, RA.NonEmptyArray<B>>
+>(2, (self, pf) => tMap.takeSomeSTM(self.tMap, (key) => pf(key)))
+
+/** @internal */
+export const toChunk = <A>(self: TSet.TSet<A>): STM.STM<never, never, Array<A>> => tMap.keys(self.tMap)
+
+/** @internal */
+export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<never, never, HashSet.HashSet<A>> =>
+  reduce(
+    self,
+    HashSet.empty<A>(),
+    (acc, value) => pipe(acc, HashSet.add(value))
+  )
+
+/** @internal */
+export const toReadonlyArray = <A>(self: TSet.TSet<A>): STM.STM<never, never, ReadonlyArray<A>> =>
+  reduce<ReadonlyArray<A>, A>(
+    self,
+    [],
+    (acc, value) => [...acc, value]
+  )
+
+/** @internal */
+export const toReadonlySet = <A>(self: TSet.TSet<A>): STM.STM<never, never, ReadonlySet<A>> =>
+  core.map(toReadonlyArray(self), (values) => new Set(values))
+
+/** @internal */
+export const transform = dual<
+  <A>(f: (a: A) => A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
+  <A>(self: TSet.TSet<A>, f: (a: A) => A) => STM.STM<never, never, 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<R, E, A>) => (self: TSet.TSet<A>) => STM.STM<R, E, void>,
+  <A, R, E>(self: TSet.TSet<A>, f: (a: A) => STM.STM<R, E, A>) => STM.STM<R, E, void>
+>(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<never, never, void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+>(2, (self, other) => forEach(other, (value) => add(self, value)))

package/src/internal/stream/debounceState.ts

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

package/src/internal/stream/emit.ts

@@ -0,0 +1,46 @@
+import * as Cause from "../../Cause"
+import * as Chunk from "../../Chunk"
+import * as Effect from "../../Effect"
+import * as Exit from "../../Exit"
+import { pipe } from "../../Function"
+import * as Option from "../../Option"
+import type * as Emit from "../../StreamEmit"
+
+/** @internal */
+export const make = <R, E, A, B>(
+  emit: (f: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>) => Promise<B>
+): Emit.Emit<R, E, A, B> => {
+  const ops: Emit.EmitOps<R, E, A, B> = {
+    chunk(this: Emit.Emit<R, E, A, B>, as: Chunk.Chunk<A>) {
+      return this(Effect.succeed(as))
+    },
+    die<Err>(this: Emit.Emit<R, E, A, B>, defect: Err) {
+      return this(Effect.die(defect))
+    },
+    dieMessage(this: Emit.Emit<R, E, A, B>, message: string) {
+      return this(Effect.dieMessage(message))
+    },
+    done(this: Emit.Emit<R, E, A, B>, exit: Exit.Exit<E, A>) {
+      return this(Effect.suspend(() => Exit.mapBoth(exit, { onFailure: Option.some, onSuccess: Chunk.of })))
+    },
+    end(this: Emit.Emit<R, E, A, B>) {
+      return this(Effect.fail(Option.none()))
+    },
+    fail(this: Emit.Emit<R, E, A, B>, e: E) {
+      return this(Effect.fail(Option.some(e)))
+    },
+    fromEffect(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<R, E, A>) {
+      return this(Effect.mapBoth(effect, { onFailure: Option.some, onSuccess: Chunk.of }))
+    },
+    fromEffectChunk(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<R, E, Chunk.Chunk<A>>) {
+      return this(pipe(effect, Effect.mapError(Option.some)))
+    },
+    halt(this: Emit.Emit<R, E, A, B>, cause: Cause.Cause<E>) {
+      return this(Effect.failCause(pipe(cause, Cause.map(Option.some))))
+    },
+    single(this: Emit.Emit<R, E, A, B>, value: A) {
+      return this(Effect.succeed(Chunk.of(value)))
+    }
+  }
+  return Object.assign(emit, ops)
+}

package/src/internal/stream/haltStrategy.ts

@@ -0,0 +1,85 @@
+import { dual } from "../../Function"
+import type * as HaltStrategy from "../../StreamHaltStrategy"
+import * as OpCodes from "../opCodes/streamHaltStrategy"
+
+/** @internal */
+export const Left: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_LEFT
+}
+
+/** @internal */
+export const Right: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_RIGHT
+}
+
+/** @internal */
+export const Both: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_BOTH
+}
+
+/** @internal */
+export const Either: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_EITHER
+}
+
+/** @internal */
+export const fromInput = (input: HaltStrategy.HaltStrategyInput): HaltStrategy.HaltStrategy => {
+  switch (input) {
+    case "left":
+      return Left
+    case "right":
+      return Right
+    case "both":
+      return Both
+    case "either":
+      return Either
+    default:
+      return input
+  }
+}
+
+/** @internal */
+export const isLeft = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Left => self._tag === OpCodes.OP_LEFT
+
+/** @internal */
+export const isRight = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Right => self._tag === OpCodes.OP_RIGHT
+
+/** @internal */
+export const isBoth = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Both => self._tag === OpCodes.OP_BOTH
+
+/** @internal */
+export const isEither = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Either =>
+  self._tag === OpCodes.OP_EITHER
+
+/** @internal */
+export const match = dual<
+  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z) => (self: HaltStrategy.HaltStrategy) => Z,
+  <Z>(
+    self: HaltStrategy.HaltStrategy,
+    onLeft: () => Z,
+    onRight: () => Z,
+    onBoth: () => Z,
+    onEither: () => Z
+  ) => Z
+>(5, <Z>(
+  self: HaltStrategy.HaltStrategy,
+  onLeft: () => Z,
+  onRight: () => Z,
+  onBoth: () => Z,
+  onEither: () => Z
+): Z => {
+  switch (self._tag) {
+    case OpCodes.OP_LEFT: {
+      return onLeft()
+    }
+    case OpCodes.OP_RIGHT: {
+      return onRight()
+    }
+    case OpCodes.OP_BOTH: {
+      return onBoth()
+    }
+    case OpCodes.OP_EITHER: {
+      return onEither()
+    }
+  }
+})

package/src/internal/stream/handoff.ts

@@ -0,0 +1,185 @@
+import * as Deferred from "../../Deferred"
+import * as Effect from "../../Effect"
+import { dual, pipe } from "../../Function"
+import * as Option from "../../Option"
+import * as Ref from "../../Ref"
+
+/** @internal */
+export const HandoffTypeId = Symbol.for("effect/Stream/Handoff")
+
+/** @internal */
+export type HandoffTypeId = typeof HandoffTypeId
+
+/**
+ * A synchronous queue-like abstraction that allows a producer to offer an
+ * element and wait for it to be taken, and allows a consumer to wait for an
+ * element to be available.
+ *
+ * @internal
+ */
+export interface Handoff<A> extends Handoff.Variance<A> {
+  readonly ref: Ref.Ref<Handoff.State<A>>
+}
+
+/** @internal */
+export const OP_HANDOFF_STATE_EMPTY = "Empty" as const
+
+/** @internal */
+export type OP_HANDOFF_STATE_EMPTY = typeof OP_HANDOFF_STATE_EMPTY
+
+/** @internal */
+export const OP_HANDOFF_STATE_FULL = "Full" as const
+
+/** @internal */
+export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL
+
+/** @internal */
+export declare namespace Handoff {
+  /** @internal */
+  export interface Variance<A> {
+    readonly [HandoffTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+
+  /** @internal */
+  export type State<A> = Empty | Full<A>
+
+  /** @internal */
+  export interface Empty {
+    readonly _tag: OP_HANDOFF_STATE_EMPTY
+    readonly notifyConsumer: Deferred.Deferred<never, void>
+  }
+
+  /** @internal */
+  export interface Full<A> {
+    readonly _tag: OP_HANDOFF_STATE_FULL
+    readonly value: A
+    readonly notifyProducer: Deferred.Deferred<never, void>
+  }
+}
+
+/** @internal */
+const handoffStateEmpty = (notifyConsumer: Deferred.Deferred<never, void>): Handoff.State<never> => ({
+  _tag: OP_HANDOFF_STATE_EMPTY,
+  notifyConsumer
+})
+
+/** @internal */
+const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<never, void>): Handoff.State<A> => ({
+  _tag: OP_HANDOFF_STATE_FULL,
+  value,
+  notifyProducer
+})
+
+/** @internal */
+const handoffStateMatch = <A, Z>(
+  onEmpty: (notifyConsumer: Deferred.Deferred<never, void>) => Z,
+  onFull: (value: A, notifyProducer: Deferred.Deferred<never, void>) => Z
+) => {
+  return (self: Handoff.State<A>): Z => {
+    switch (self._tag) {
+      case OP_HANDOFF_STATE_EMPTY: {
+        return onEmpty(self.notifyConsumer)
+      }
+      case OP_HANDOFF_STATE_FULL: {
+        return onFull(self.value, self.notifyProducer)
+      }
+    }
+  }
+}
+
+/** @internal */
+const handoffVariance = {
+  _A: (_: never) => _
+}
+
+/** @internal */
+export const make = <A>(): Effect.Effect<never, never, Handoff<A>> =>
+  pipe(
+    Deferred.make<never, void>(),
+    Effect.flatMap((deferred) => Ref.make(handoffStateEmpty(deferred))),
+    Effect.map((ref) => ({
+      [HandoffTypeId]: handoffVariance,
+      ref
+    }))
+  )
+
+/** @internal */
+export const offer = dual<
+  <A>(value: A) => (self: Handoff<A>) => Effect.Effect<never, never, void>,
+  <A>(self: Handoff<A>, value: A) => Effect.Effect<never, never, void>
+>(2, (self, value): Effect.Effect<never, never, void> => {
+  return Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            (notifyConsumer) => [
+              Effect.zipRight(
+                Deferred.succeed<never, void>(notifyConsumer, void 0),
+                Deferred.await(deferred)
+              ),
+              handoffStateFull(value, deferred)
+            ],
+            (_, notifyProducer) => [
+              Effect.flatMap(
+                Deferred.await(notifyProducer),
+                () => pipe(self, offer(value))
+              ),
+              state
+            ]
+          )
+        ))
+    ))
+})
+
+/** @internal */
+export const take = <A>(self: Handoff<A>): Effect.Effect<never, never, A> =>
+  Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            (notifyConsumer) => [
+              Effect.flatMap(
+                Deferred.await(notifyConsumer),
+                () => take(self)
+              ),
+              state
+            ],
+            (value, notifyProducer) => [
+              Effect.as(
+                Deferred.succeed<never, void>(notifyProducer, void 0),
+                value
+              ),
+              handoffStateEmpty(deferred)
+            ]
+          )
+        ))
+    ))
+
+/** @internal */
+export const poll = <A>(self: Handoff<A>): Effect.Effect<never, never, Option.Option<A>> =>
+  Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            () => [
+              Effect.succeed(Option.none<A>()),
+              state
+            ],
+            (value, notifyProducer) => [
+              Effect.as(
+                Deferred.succeed<never, void>(notifyProducer, void 0),
+                Option.some(value)
+              ),
+              handoffStateEmpty(deferred)
+            ]
+          )
+        ))
+    ))

package/src/internal/stream/handoffSignal.ts

@@ -0,0 +1,59 @@
+import type * as Cause from "../../Cause"
+import type * as Chunk from "../../Chunk"
+import type * as SinkEndReason from "./sinkEndReason"
+
+/** @internal */
+export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End
+
+/** @internal */
+export const OP_EMIT = "Emit" as const
+
+/** @internal */
+export type OP_EMIT = typeof OP_EMIT
+
+/** @internal */
+export const OP_HALT = "Halt" as const
+
+/** @internal */
+export type OP_HALT = typeof OP_HALT
+
+/** @internal */
+export const OP_END = "End" as const
+
+/** @internal */
+export type OP_END = typeof OP_END
+
+export interface Emit<A> {
+  readonly _tag: OP_EMIT
+  readonly elements: Chunk.Chunk<A>
+}
+
+/** @internal */
+export interface Halt<E> {
+  readonly _tag: OP_HALT
+  readonly cause: Cause.Cause<E>
+}
+
+/** @internal */
+export interface End {
+  readonly _tag: OP_END
+  readonly reason: SinkEndReason.SinkEndReason
+}
+
+/** @internal */
+export const emit = <A>(elements: Chunk.Chunk<A>): HandoffSignal<never, A> => ({
+  _tag: OP_EMIT,
+  elements
+})
+
+/** @internal */
+export const halt = <E>(cause: Cause.Cause<E>): HandoffSignal<E, never> => ({
+  _tag: OP_HALT,
+  cause
+})
+
+/** @internal */
+export const end = (reason: SinkEndReason.SinkEndReason): HandoffSignal<never, never> => ({
+  _tag: OP_END,
+  reason
+})