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

package/src/internal/channel/channelState.ts

@@ -0,0 +1,132 @@
+import * as Effect from "../../Effect"
+import type * as Exit from "../../Exit"
+import * as OpCodes from "../opCodes/channelState"
+import type { ErasedExecutor } from "./channelExecutor"
+
+/** @internal */
+export const ChannelStateTypeId = Symbol.for("effect/ChannelState")
+
+/** @internal */
+export type ChannelStateTypeId = typeof ChannelStateTypeId
+
+/** @internal */
+export interface ChannelState<R, E> extends ChannelState.Variance<R, E> {}
+
+/** @internal */
+export declare namespace ChannelState {
+  export interface Variance<R, E> {
+    readonly [ChannelStateTypeId]: {
+      readonly _R: (_: never) => R
+      readonly _E: (_: never) => E
+    }
+  }
+}
+
+/** @internal */
+const channelStateVariance = {
+  _R: (_: never) => _,
+  _E: (_: never) => _
+}
+
+/** @internal */
+const proto = {
+  [ChannelStateTypeId]: channelStateVariance
+}
+
+/** @internal */
+export type Primitive =
+  | Done
+  | Emit
+  | FromEffect
+  | Read
+
+/** @internal */
+export type Op<Tag extends string, Body = {}> = ChannelState<never, never> & Body & {
+  readonly _tag: Tag
+}
+
+/** @internal */
+export interface Done extends Op<OpCodes.OP_DONE, {}> {}
+
+/** @internal */
+export interface Emit extends Op<OpCodes.OP_EMIT, {}> {}
+
+/** @internal */
+export interface FromEffect extends
+  Op<OpCodes.OP_FROM_EFFECT, {
+    readonly effect: Effect.Effect<unknown, unknown, unknown>
+  }>
+{}
+
+/** @internal */
+export interface Read extends
+  Op<OpCodes.OP_READ, {
+    readonly upstream: ErasedExecutor<unknown>
+    readonly onEffect: (effect: Effect.Effect<unknown, never, void>) => Effect.Effect<unknown, never, void>
+    readonly onEmit: (value: unknown) => Effect.Effect<unknown, never, void>
+    readonly onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, void>
+  }>
+{}
+
+/** @internal */
+export const Done = (): ChannelState<never, never> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_DONE
+  return op
+}
+
+/** @internal */
+export const Emit = (): ChannelState<never, never> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_EMIT
+  return op
+}
+
+/** @internal */
+export const FromEffect = <R, E, _>(effect: Effect.Effect<R, E, _>): ChannelState<R, E> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_FROM_EFFECT
+  op.effect = effect
+  return op
+}
+
+/** @internal */
+export const Read = <R>(
+  upstream: ErasedExecutor<R>,
+  onEffect: (effect: Effect.Effect<R, never, void>) => Effect.Effect<R, never, void>,
+  onEmit: (value: unknown) => Effect.Effect<R, never, void> | undefined,
+  onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, void> | undefined
+): ChannelState<R, never> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_READ
+  op.upstream = upstream
+  op.onEffect = onEffect
+  op.onEmit = onEmit
+  op.onDone = onDone
+  return op
+}
+
+/** @internal */
+export const isChannelState = (u: unknown): u is ChannelState<unknown, unknown> =>
+  typeof u === "object" && u != null && ChannelStateTypeId in u
+
+/** @internal */
+export const isDone = <R, E>(self: ChannelState<R, E>): self is Done => (self as Primitive)._tag === OpCodes.OP_DONE
+
+/** @internal */
+export const isEmit = <R, E>(self: ChannelState<R, E>): self is Emit => (self as Primitive)._tag === OpCodes.OP_EMIT
+
+/** @internal */
+export const isFromEffect = <R, E>(self: ChannelState<R, E>): self is FromEffect =>
+  (self as Primitive)._tag === OpCodes.OP_FROM_EFFECT
+
+/** @internal */
+export const isRead = <R, E>(self: ChannelState<R, E>): self is Read => (self as Primitive)._tag === OpCodes.OP_READ
+
+/** @internal */
+export const effect = <R, E>(self: ChannelState<R, E>): Effect.Effect<R, E, void> =>
+  isFromEffect(self) ? self.effect as Effect.Effect<R, E, void> : Effect.unit
+
+/** @internal */
+export const effectOrUndefinedIgnored = <R, E>(self: ChannelState<R, E>): Effect.Effect<R, E, void> | undefined =>
+  isFromEffect(self) ? Effect.ignore(self.effect as Effect.Effect<R, E, void>) : undefined

package/src/internal/channel/childExecutorDecision.ts

@@ -0,0 +1,95 @@
+import type * as ChildExecutorDecision from "../../ChannelChildExecutorDecision"
+import { dual } from "../../Function"
+import * as OpCodes from "../opCodes/channelChildExecutorDecision"
+
+/** @internal */
+const ChildExecutorDecisionSymbolKey = "effect/ChannelChildExecutorDecision"
+
+/** @internal */
+export const ChildExecutorDecisionTypeId: ChildExecutorDecision.ChildExecutorDecisionTypeId = Symbol.for(
+  ChildExecutorDecisionSymbolKey
+) as ChildExecutorDecision.ChildExecutorDecisionTypeId
+
+/** @internal */
+const proto = {
+  [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId
+}
+
+/** @internal */
+export const Continue = (_: void): ChildExecutorDecision.ChildExecutorDecision => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_CONTINUE
+  return op
+}
+
+/** @internal */
+export const Close = (value: unknown): ChildExecutorDecision.ChildExecutorDecision => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_CLOSE
+  op.value = value
+  return op
+}
+
+/** @internal */
+export const Yield = (_: void): ChildExecutorDecision.ChildExecutorDecision => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_YIELD
+  return op
+}
+
+/** @internal */
+export const isChildExecutorDecision = (u: unknown): u is ChildExecutorDecision.ChildExecutorDecision =>
+  typeof u === "object" && u != null && ChildExecutorDecisionTypeId in u
+
+/** @internal */
+export const isContinue = (
+  self: ChildExecutorDecision.ChildExecutorDecision
+): self is ChildExecutorDecision.Continue => self._tag === OpCodes.OP_CONTINUE
+
+/** @internal */
+export const isClose = (
+  self: ChildExecutorDecision.ChildExecutorDecision
+): self is ChildExecutorDecision.Close => self._tag === OpCodes.OP_CLOSE
+
+/** @internal */
+export const isYield = (
+  self: ChildExecutorDecision.ChildExecutorDecision
+): self is ChildExecutorDecision.Yield => self._tag === OpCodes.OP_YIELD
+
+/** @internal */
+export const match = dual<
+  <A>(
+    options: {
+      readonly onContinue: () => A
+      readonly onClose: (value: unknown) => A
+      readonly onYield: () => A
+    }
+  ) => (self: ChildExecutorDecision.ChildExecutorDecision) => A,
+  <A>(
+    self: ChildExecutorDecision.ChildExecutorDecision,
+    options: {
+      readonly onContinue: () => A
+      readonly onClose: (value: unknown) => A
+      readonly onYield: () => A
+    }
+  ) => A
+>(2, <A>(
+  self: ChildExecutorDecision.ChildExecutorDecision,
+  { onClose, onContinue, onYield }: {
+    readonly onContinue: () => A
+    readonly onClose: (value: unknown) => A
+    readonly onYield: () => A
+  }
+): A => {
+  switch (self._tag) {
+    case OpCodes.OP_CONTINUE: {
+      return onContinue()
+    }
+    case OpCodes.OP_CLOSE: {
+      return onClose(self.value)
+    }
+    case OpCodes.OP_YIELD: {
+      return onYield()
+    }
+  }
+})

package/src/internal/channel/continuation.ts

@@ -0,0 +1,171 @@
+import type * as Cause from "../../Cause"
+import type * as Channel from "../../Channel"
+import type * as Effect from "../../Effect"
+import * as Exit from "../../Exit"
+import * as OpCodes from "../opCodes/continuation"
+
+/** @internal */
+export const ContinuationTypeId = Symbol.for("effect/ChannelContinuation")
+
+/** @internal */
+export type ContinuationTypeId = typeof ContinuationTypeId
+
+/** @internal */
+export interface Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>
+  extends Continuation.Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>
+{}
+
+/** @internal */
+export declare namespace Continuation {
+  /** @internal */
+  export interface Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
+    readonly [ContinuationTypeId]: {
+      readonly _Env: (_: never) => Env
+      readonly _InErr: (_: InErr) => void
+      readonly _InElem: (_: InElem) => void
+      readonly _InDone: (_: InDone) => void
+      readonly _OutErr: (_: never) => OutErr
+      readonly _OutDone: (_: never) => OutDone
+      readonly _OutErr2: (_: never) => OutErr2
+      readonly _OutElem: (_: never) => OutElem
+      readonly _OutDone2: (_: never) => OutDone2
+    }
+  }
+}
+
+/** @internal */
+export type Primitive = ErasedContinuationK | ErasedContinuationFinalizer
+
+/** @internal */
+export type ErasedContinuationK = ContinuationK<
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>
+
+/** @internal */
+export type ErasedContinuationFinalizer = ContinuationFinalizer<unknown, unknown, unknown>
+
+/** @internal */
+export interface ContinuationK<
+  Env,
+  InErr,
+  InElem,
+  InDone,
+  OutErr,
+  OutErr2,
+  OutElem,
+  OutDone,
+  OutDone2
+> extends
+  Continuation<
+    Env,
+    InErr,
+    InElem,
+    InDone,
+    OutErr,
+    OutErr2,
+    OutElem,
+    OutDone,
+    OutDone2
+  >
+{
+  readonly _tag: OpCodes.OP_CONTINUATION_K
+  readonly onSuccess: (
+    o: OutDone
+  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  readonly onHalt: (
+    c: Cause.Cause<OutErr>
+  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  readonly onExit: (
+    exit: Exit.Exit<OutErr, OutDone>
+  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+}
+
+/** @internal */
+export interface ContinuationFinalizer<Env, OutErr, OutDone> extends
+  Continuation<
+    Env,
+    unknown,
+    unknown,
+    unknown,
+    OutErr,
+    never,
+    never,
+    OutDone,
+    never
+  >
+{
+  readonly _tag: OpCodes.OP_CONTINUATION_FINALIZER
+  readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, unknown>
+}
+
+/** @internal */
+const continuationVariance = {
+  _Env: (_: never) => _,
+  _InErr: (_: unknown) => _,
+  _InElem: (_: unknown) => _,
+  _InDone: (_: unknown) => _,
+  _OutErr: (_: never) => _,
+  _OutDone: (_: never) => _,
+  _OutErr2: (_: never) => _,
+  _OutElem: (_: never) => _,
+  _OutDone2: (_: never) => _
+}
+
+/** @internal */
+export class ContinuationKImpl<
+  Env,
+  Env2,
+  InErr,
+  InElem,
+  InDone,
+  OutErr,
+  OutErr2,
+  OutElem,
+  OutDone,
+  OutDone2
+> implements
+  ContinuationK<
+    Env | Env2,
+    InErr,
+    InElem,
+    InDone,
+    OutErr,
+    OutErr2,
+    OutElem,
+    OutDone,
+    OutDone2
+  >
+{
+  readonly _tag = OpCodes.OP_CONTINUATION_K
+  readonly [ContinuationTypeId] = continuationVariance
+  constructor(
+    readonly onSuccess: (
+      o: OutDone
+    ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>,
+    readonly onHalt: (
+      c: Cause.Cause<OutErr>
+    ) => Channel.Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ) {
+  }
+  onExit(
+    exit: Exit.Exit<OutErr, OutDone>
+  ): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2> {
+    return Exit.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value)
+  }
+}
+
+/** @internal */
+export class ContinuationFinalizerImpl<Env, OutErr, OutDone> implements ContinuationFinalizer<Env, OutErr, OutDone> {
+  readonly _tag = OpCodes.OP_CONTINUATION_FINALIZER
+  readonly [ContinuationTypeId] = continuationVariance
+  constructor(readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, unknown>) {
+  }
+}

package/src/internal/channel/mergeDecision.ts

@@ -0,0 +1,115 @@
+import type * as MergeDecision from "../../ChannelMergeDecision"
+import type * as Effect from "../../Effect"
+import type * as Exit from "../../Exit"
+import { dual } from "../../Function"
+import * as OpCodes from "../opCodes/channelMergeDecision"
+
+/** @internal */
+const MergeDecisionSymbolKey = "effect/ChannelMergeDecision"
+
+/** @internal */
+export const MergeDecisionTypeId: MergeDecision.MergeDecisionTypeId = Symbol.for(
+  MergeDecisionSymbolKey
+) as MergeDecision.MergeDecisionTypeId
+
+/** @internal */
+const proto = {
+  [MergeDecisionTypeId]: {
+    _R: (_: never) => _,
+    _E0: (_: unknown) => _,
+    _Z0: (_: unknown) => _,
+    _E: (_: never) => _,
+    _Z: (_: never) => _
+  }
+}
+
+/** @internal */
+export type Primitive =
+  | Done
+  | Await
+
+/** @internal */
+export type Op<Tag extends string, Body = {}> =
+  & MergeDecision.MergeDecision<never, unknown, unknown, never, never>
+  & Body
+  & {
+    readonly _tag: Tag
+  }
+
+/** @internal */
+export interface Done extends
+  Op<OpCodes.OP_DONE, {
+    readonly effect: Effect.Effect<never, never, never>
+  }>
+{}
+
+/** @internal */
+export interface Await extends
+  Op<OpCodes.OP_AWAIT, {
+    readonly f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, never>
+  }>
+{}
+
+/** @internal */
+export const Done = <R, E, Z>(
+  effect: Effect.Effect<R, E, Z>
+): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_DONE
+  op.effect = effect
+  return op
+}
+
+/** @internal */
+export const Await = <R, E0, Z0, E, Z>(
+  f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>
+): MergeDecision.MergeDecision<R, E0, Z0, E, Z> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_AWAIT
+  op.f = f
+  return op
+}
+
+/** @internal */
+export const AwaitConst = <R, E, Z>(
+  effect: Effect.Effect<R, E, Z>
+): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => Await(() => effect)
+
+/** @internal */
+export const isMergeDecision = (
+  u: unknown
+): u is MergeDecision.MergeDecision<unknown, unknown, unknown, unknown, unknown> =>
+  typeof u === "object" && u != null && MergeDecisionTypeId in u
+
+/** @internal */
+export const match = dual<
+  <R, E0, Z0, E, Z, Z2>(
+    options: {
+      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+    }
+  ) => (self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>) => Z2,
+  <R, E0, Z0, E, Z, Z2>(
+    self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>,
+    options: {
+      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+    }
+  ) => Z2
+>(2, <R, E0, Z0, E, Z, Z2>(
+  self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>,
+  { onAwait, onDone }: {
+    readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
+    readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+  }
+): Z2 => {
+  const op = self as Primitive
+  switch (op._tag) {
+    case OpCodes.OP_DONE: {
+      return onDone(op.effect)
+    }
+    case OpCodes.OP_AWAIT: {
+      return onAwait(op.f)
+    }
+  }
+})

package/src/internal/channel/mergeState.ts

@@ -0,0 +1,120 @@
+import type * as MergeState from "../../ChannelMergeState"
+import type * as Effect from "../../Effect"
+import type * as Either from "../../Either"
+import type * as Exit from "../../Exit"
+import type * as Fiber from "../../Fiber"
+import { dual } from "../../Function"
+import * as OpCodes from "../opCodes/channelMergeState"
+
+/** @internal */
+const MergeStateSymbolKey = "effect/ChannelMergeState"
+
+/** @internal */
+export const MergeStateTypeId: MergeState.MergeStateTypeId = Symbol.for(
+  MergeStateSymbolKey
+) as MergeState.MergeStateTypeId
+
+/** @internal */
+const proto = {
+  [MergeStateTypeId]: MergeStateTypeId
+}
+
+/** @internal */
+export const BothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_BOTH_RUNNING
+  op.left = left
+  op.right = right
+  return op
+}
+
+/** @internal */
+export const LeftDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_LEFT_DONE
+  op.f = f
+  return op
+}
+
+/** @internal */
+export const RightDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_RIGHT_DONE
+  op.f = f
+  return op
+}
+
+/** @internal */
+export const isMergeState = (
+  u: unknown
+): u is MergeState.MergeState<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> => {
+  return typeof u === "object" && u != null && MergeStateTypeId in u
+}
+
+/** @internal */
+export const isBothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+): self is MergeState.BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  return self._tag === OpCodes.OP_BOTH_RUNNING
+}
+
+/** @internal */
+export const isLeftDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+): self is MergeState.LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  return self._tag === OpCodes.OP_LEFT_DONE
+}
+
+/** @internal */
+export const isRightDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+): self is MergeState.RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
+  return self._tag === OpCodes.OP_RIGHT_DONE
+}
+
+/** @internal */
+export const match = dual<
+  <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
+    options: {
+      readonly onBothRunning: (
+        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+    }
+  ) => (self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>) => Z,
+  <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
+    self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
+    options: {
+      readonly onBothRunning: (
+        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+    }
+  ) => Z
+>(2, (
+  self,
+  { onBothRunning, onLeftDone, onRightDone }
+) => {
+  switch (self._tag) {
+    case OpCodes.OP_BOTH_RUNNING: {
+      return onBothRunning(self.left, self.right)
+    }
+    case OpCodes.OP_LEFT_DONE: {
+      return onLeftDone(self.f)
+    }
+    case OpCodes.OP_RIGHT_DONE: {
+      return onRightDone(self.f)
+    }
+  }
+})

package/src/internal/channel/mergeStrategy.ts

@@ -0,0 +1,72 @@
+import type * as MergeStrategy from "../../ChannelMergeStrategy"
+import { dual } from "../../Function"
+import * as OpCodes from "../opCodes/channelMergeStrategy"
+
+/** @internal */
+const MergeStrategySymbolKey = "effect/ChannelMergeStrategy"
+
+/** @internal */
+export const MergeStrategyTypeId: MergeStrategy.MergeStrategyTypeId = Symbol.for(
+  MergeStrategySymbolKey
+) as MergeStrategy.MergeStrategyTypeId
+
+/** @internal */
+const proto = {
+  [MergeStrategyTypeId]: MergeStrategyTypeId
+}
+
+/** @internal */
+export const BackPressure = (_: void): MergeStrategy.MergeStrategy => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_BACK_PRESSURE
+  return op
+}
+
+/** @internal */
+export const BufferSliding = (_: void): MergeStrategy.MergeStrategy => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_BUFFER_SLIDING
+  return op
+}
+
+/** @internal */
+export const isMergeStrategy = (u: unknown): u is MergeStrategy.MergeStrategy =>
+  typeof u === "object" && u != null && MergeStrategyTypeId in u
+
+/** @internal */
+export const isBackPressure = (self: MergeStrategy.MergeStrategy): self is MergeStrategy.BackPressure =>
+  self._tag === OpCodes.OP_BACK_PRESSURE
+
+/** @internal */
+export const isBufferSliding = (self: MergeStrategy.MergeStrategy): self is MergeStrategy.BufferSliding =>
+  self._tag === OpCodes.OP_BUFFER_SLIDING
+
+/** @internal */
+export const match = dual<
+  <A>(options: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }) => (self: MergeStrategy.MergeStrategy) => A,
+  <A>(
+    self: MergeStrategy.MergeStrategy,
+    options: {
+      readonly onBackPressure: () => A
+      readonly onBufferSliding: () => A
+    }
+  ) => A
+>(2, <A>(
+  self: MergeStrategy.MergeStrategy,
+  { onBackPressure, onBufferSliding }: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }
+): A => {
+  switch (self._tag) {
+    case OpCodes.OP_BACK_PRESSURE: {
+      return onBackPressure()
+    }
+    case OpCodes.OP_BUFFER_SLIDING: {
+      return onBufferSliding()
+    }
+  }
+})