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

package/src/internal/stm/core.ts

@@ -1,817 +0,0 @@
-import * as Cause from "../../Cause.js"
-import * as Context from "../../Context.js"
-import * as Effect from "../../Effect.js"
-import * as Either from "../../Either.js"
-import * as Equal from "../../Equal.js"
-import * as Exit from "../../Exit.js"
-import type * as FiberId from "../../FiberId.js"
-import * as FiberRef from "../../FiberRef.js"
-import type { LazyArg } from "../../Function.js"
-import { constVoid, dual, pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import type * as Option from "../../Option.js"
-import { pipeArguments } from "../../Pipeable.js"
-import { hasProperty } from "../../Predicate.js"
-import type * as Scheduler from "../../Scheduler.js"
-import type * as STM from "../../STM.js"
-import { internalCall, YieldWrap } from "../../Utils.js"
-import { ChannelTypeId } from "../core-stream.js"
-import { withFiberRuntime } from "../core.js"
-import { effectVariance, StreamTypeId } from "../effectable.js"
-import { OP_COMMIT } from "../opCodes/effect.js"
-import { SingleShotGen } from "../singleShotGen.js"
-import { SinkTypeId } from "../sink.js"
-import * as Journal from "./journal.js"
-import * as OpCodes from "./opCodes/stm.js"
-import * as TExitOpCodes from "./opCodes/tExit.js"
-import * as TryCommitOpCodes from "./opCodes/tryCommit.js"
-import * as STMState from "./stmState.js"
-import * as TExit from "./tExit.js"
-import * as TryCommit from "./tryCommit.js"
-import * as TxnId from "./txnId.js"
-
-/** @internal */
-const STMSymbolKey = "effect/STM"
-
-/** @internal */
-export const STMTypeId: STM.STMTypeId = Symbol.for(
-  STMSymbolKey
-) as STM.STMTypeId
-
-/** @internal */
-export type Primitive =
-  | STMEffect
-  | STMOnFailure
-  | STMOnRetry
-  | STMOnSuccess
-  | STMProvide
-  | STMSync
-  | STMSucceed
-  | STMRetry
-  | STMFail
-  | STMDie
-  | STMInterrupt
-
-/** @internal */
-type Op<Tag extends string, Body = {}> = STM.STM<never> & Body & {
-  readonly _op: OP_COMMIT
-  readonly effect_instruction_i0: Tag
-}
-
-/** @internal */
-interface STMEffect extends
-  Op<OpCodes.OP_WITH_STM_RUNTIME, {
-    readonly effect_instruction_i1: (
-      runtime: STMDriver<unknown, unknown, unknown>
-    ) => STM.STM<unknown, unknown, unknown>
-  }>
-{}
-
-/** @internal */
-interface STMOnFailure extends
-  Op<OpCodes.OP_ON_FAILURE, {
-    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
-    readonly effect_instruction_i2: (error: unknown) => STM.STM<unknown, unknown, unknown>
-  }>
-{}
-
-/** @internal */
-interface STMOnRetry extends
-  Op<OpCodes.OP_ON_RETRY, {
-    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
-    readonly effect_instruction_i2: () => STM.STM<unknown, unknown, unknown>
-  }>
-{}
-
-/** @internal */
-interface STMOnSuccess extends
-  Op<OpCodes.OP_ON_SUCCESS, {
-    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
-    readonly effect_instruction_i2: (a: unknown) => STM.STM<unknown, unknown, unknown>
-  }>
-{}
-
-/** @internal */
-interface STMProvide extends
-  Op<OpCodes.OP_PROVIDE, {
-    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
-    readonly effect_instruction_i2: (context: Context.Context<unknown>) => Context.Context<unknown>
-  }>
-{}
-
-/** @internal */
-interface STMSync extends
-  Op<OpCodes.OP_SYNC, {
-    readonly effect_instruction_i1: () => unknown
-  }>
-{}
-
-/** @internal */
-interface STMSucceed extends
-  Op<OpCodes.OP_SUCCEED, {
-    readonly effect_instruction_i1: unknown
-  }>
-{}
-
-/** @internal */
-interface STMRetry extends Op<OpCodes.OP_RETRY, {}> {}
-
-/** @internal */
-interface STMFail extends
-  Op<OpCodes.OP_FAIL, {
-    readonly effect_instruction_i1: LazyArg<unknown>
-  }>
-{}
-
-/** @internal */
-interface STMDie extends
-  Op<OpCodes.OP_DIE, {
-    readonly effect_instruction_i1: LazyArg<unknown>
-  }>
-{}
-
-/** @internal */
-interface STMInterrupt extends
-  Op<OpCodes.OP_INTERRUPT, {
-    readonly effect_instruction_i1: FiberId.Runtime
-  }>
-{}
-
-const stmVariance = {
-  /* c8 ignore next */
-  _R: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _,
-  /* c8 ignore next */
-  _A: (_: never) => _
-}
-
-/** @internal */
-class STMPrimitive implements STM.STM<any, any, any> {
-  public _op = OP_COMMIT
-  public effect_instruction_i1: any = undefined
-  public effect_instruction_i2: any = undefined;
-  [Effect.EffectTypeId]: any;
-  [StreamTypeId]: any;
-  [SinkTypeId]: any;
-  [ChannelTypeId]: any
-  get [STMTypeId]() {
-    return stmVariance
-  }
-  constructor(readonly effect_instruction_i0: Primitive["effect_instruction_i0"]) {
-    this[Effect.EffectTypeId] = effectVariance
-    this[StreamTypeId] = stmVariance
-    this[SinkTypeId] = stmVariance
-    this[ChannelTypeId] = stmVariance
-  }
-  [Equal.symbol](this: {}, that: unknown) {
-    return this === that
-  }
-  [Hash.symbol](this: {}) {
-    return Hash.cached(this, Hash.random(this))
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this)) as any
-  }
-  commit(this: STM.STM<any, any, any>): Effect.Effect<any, any, any> {
-    return unsafeAtomically(this, constVoid, constVoid)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const isSTM = (u: unknown): u is STM.STM<unknown, unknown, unknown> => hasProperty(u, STMTypeId)
-
-/** @internal */
-export const commit = <A, E, R>(self: STM.STM<A, E, R>): Effect.Effect<A, E, R> =>
-  unsafeAtomically(self, constVoid, constVoid)
-
-/** @internal */
-export const unsafeAtomically = <A, E, R>(
-  self: STM.STM<A, E, R>,
-  onDone: (exit: Exit.Exit<A, E>) => unknown,
-  onInterrupt: LazyArg<unknown>
-): Effect.Effect<A, E, R> =>
-  withFiberRuntime((state) => {
-    const fiberId = state.id()
-    const env = state.getFiberRef(FiberRef.currentContext) as Context.Context<R>
-    const scheduler = state.getFiberRef(FiberRef.currentScheduler)
-    const priority = state.getFiberRef(FiberRef.currentSchedulingPriority)
-    const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority)
-    switch (commitResult._tag) {
-      case TryCommitOpCodes.OP_DONE: {
-        onDone(commitResult.exit)
-        return commitResult.exit
-      }
-      case TryCommitOpCodes.OP_SUSPEND: {
-        const txnId = TxnId.make()
-        const state: { value: STMState.STMState<A, E> } = { value: STMState.running }
-        const effect = Effect.async(
-          (k: (effect: Effect.Effect<A, E, R>) => unknown): void =>
-            tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k)
-        )
-        return Effect.uninterruptibleMask((restore) =>
-          pipe(
-            restore(effect),
-            Effect.catchAllCause((cause) => {
-              let currentState = state.value
-              if (STMState.isRunning(currentState)) {
-                state.value = STMState.interrupted
-              }
-              currentState = state.value
-              if (STMState.isDone(currentState)) {
-                onDone(currentState.exit)
-                return currentState.exit
-              }
-              onInterrupt()
-              return Effect.failCause(cause)
-            })
-          )
-        )
-      }
-    }
-  })
-
-/** @internal */
-const tryCommit = <A, E, R>(
-  fiberId: FiberId.FiberId,
-  stm: STM.STM<A, E, R>,
-  state: { value: STMState.STMState<A, E> },
-  env: Context.Context<R>,
-  scheduler: Scheduler.Scheduler,
-  priority: number
-): TryCommit.TryCommit<A, E> => {
-  const journal: Journal.Journal = new Map()
-  const tExit = new STMDriver(stm, journal, fiberId, env).run()
-  const analysis = Journal.analyzeJournal(journal)
-
-  if (analysis === Journal.JournalAnalysisReadWrite) {
-    Journal.commitJournal(journal)
-  } else if (analysis === Journal.JournalAnalysisInvalid) {
-    throw new Error(
-      "BUG: STM.TryCommit.tryCommit - please report an issue at https://github.com/Effect-TS/effect/issues"
-    )
-  }
-
-  switch (tExit._tag) {
-    case TExitOpCodes.OP_SUCCEED: {
-      state.value = STMState.fromTExit(tExit)
-      return completeTodos(Exit.succeed(tExit.value), journal, scheduler, priority)
-    }
-    case TExitOpCodes.OP_FAIL: {
-      state.value = STMState.fromTExit(tExit)
-      const cause = Cause.fail(tExit.error)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_DIE: {
-      state.value = STMState.fromTExit(tExit)
-      const cause = Cause.die(tExit.defect)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_INTERRUPT: {
-      state.value = STMState.fromTExit(tExit)
-      const cause = Cause.interrupt(fiberId)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_RETRY: {
-      return TryCommit.suspend(journal)
-    }
-  }
-}
-
-/** @internal */
-const tryCommitSync = <A, E, R>(
-  fiberId: FiberId.FiberId,
-  stm: STM.STM<A, E, R>,
-  env: Context.Context<R>,
-  scheduler: Scheduler.Scheduler,
-  priority: number
-): TryCommit.TryCommit<A, E> => {
-  const journal: Journal.Journal = new Map()
-  const tExit = new STMDriver(stm, journal, fiberId, env).run()
-  const analysis = Journal.analyzeJournal(journal)
-
-  if (analysis === Journal.JournalAnalysisReadWrite && TExit.isSuccess(tExit)) {
-    Journal.commitJournal(journal)
-  } else if (analysis === Journal.JournalAnalysisInvalid) {
-    throw new Error(
-      "BUG: STM.TryCommit.tryCommitSync - please report an issue at https://github.com/Effect-TS/effect/issues"
-    )
-  }
-
-  switch (tExit._tag) {
-    case TExitOpCodes.OP_SUCCEED: {
-      return completeTodos(Exit.succeed(tExit.value), journal, scheduler, priority)
-    }
-    case TExitOpCodes.OP_FAIL: {
-      const cause = Cause.fail(tExit.error)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_DIE: {
-      const cause = Cause.die(tExit.defect)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_INTERRUPT: {
-      const cause = Cause.interrupt(fiberId)
-      return completeTodos(
-        Exit.failCause(cause),
-        journal,
-        scheduler,
-        priority
-      )
-    }
-    case TExitOpCodes.OP_RETRY: {
-      return TryCommit.suspend(journal)
-    }
-  }
-}
-
-/** @internal */
-const tryCommitAsync = <A, E, R>(
-  fiberId: FiberId.FiberId,
-  self: STM.STM<A, E, R>,
-  txnId: TxnId.TxnId,
-  state: { value: STMState.STMState<A, E> },
-  context: Context.Context<R>,
-  scheduler: Scheduler.Scheduler,
-  priority: number,
-  k: (effect: Effect.Effect<A, E, R>) => unknown
-) => {
-  if (STMState.isRunning(state.value)) {
-    const result = tryCommit(fiberId, self, state, context, scheduler, priority)
-    switch (result._tag) {
-      case TryCommitOpCodes.OP_DONE: {
-        completeTryCommit(result.exit, k)
-        break
-      }
-      case TryCommitOpCodes.OP_SUSPEND: {
-        Journal.addTodo(
-          txnId,
-          result.journal,
-          () => tryCommitAsync(fiberId, self, txnId, state, context, scheduler, priority, k)
-        )
-        break
-      }
-    }
-  }
-}
-
-/** @internal */
-const completeTodos = <A, E>(
-  exit: Exit.Exit<A, E>,
-  journal: Journal.Journal,
-  scheduler: Scheduler.Scheduler,
-  priority: number
-): TryCommit.TryCommit<A, E> => {
-  const todos = Journal.collectTodos(journal)
-  if (todos.size > 0) {
-    scheduler.scheduleTask(() => Journal.execTodos(todos), priority)
-  }
-  return TryCommit.done(exit)
-}
-
-/** @internal */
-const completeTryCommit = <A, E, R>(
-  exit: Exit.Exit<A, E>,
-  k: (effect: Effect.Effect<A, E, R>) => unknown
-): void => {
-  k(exit)
-}
-
-/** @internal */
-type Continuation = STMOnFailure | STMOnSuccess | STMOnRetry
-
-/** @internal */
-export const context = <R>(): STM.STM<Context.Context<R>, never, R> =>
-  effect<R, Context.Context<R>>((_, __, env) => env)
-
-/** @internal */
-export const contextWith = <R0, R>(f: (environment: Context.Context<R0>) => R): STM.STM<R, never, R0> =>
-  map(context<R0>(), f)
-
-/** @internal */
-export const contextWithSTM = <R0, A, E, R>(
-  f: (environment: Context.Context<R0>) => STM.STM<A, E, R>
-): STM.STM<A, E, R0 | R> => flatMap(context<R0>(), f)
-
-/** @internal */
-export class STMDriver<in out R, out E, out A> {
-  private contStack: Array<Continuation> = []
-  private env: Context.Context<unknown>
-
-  constructor(
-    readonly self: STM.STM<A, E, R>,
-    readonly journal: Journal.Journal,
-    readonly fiberId: FiberId.FiberId,
-    r0: Context.Context<R>
-  ) {
-    this.env = r0 as Context.Context<unknown>
-  }
-
-  getEnv(): Context.Context<R> {
-    return this.env
-  }
-
-  pushStack(cont: Continuation) {
-    this.contStack.push(cont)
-  }
-
-  popStack() {
-    return this.contStack.pop()
-  }
-
-  nextSuccess() {
-    let current = this.popStack()
-    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_SUCCESS) {
-      current = this.popStack()
-    }
-    return current
-  }
-
-  nextFailure() {
-    let current = this.popStack()
-    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_FAILURE) {
-      current = this.popStack()
-    }
-    return current
-  }
-
-  nextRetry() {
-    let current = this.popStack()
-    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_RETRY) {
-      current = this.popStack()
-    }
-    return current
-  }
-
-  run(): TExit.TExit<A, E> {
-    let curr = this.self as Primitive | Context.Tag<any, any> | Either.Either<any, any> | Option.Option<any> | undefined
-    let exit: TExit.TExit<unknown, unknown> | undefined = undefined
-    while (exit === undefined && curr !== undefined) {
-      try {
-        const current = curr
-        if (current) {
-          switch (current._op) {
-            case "Tag": {
-              curr = effect((_, __, env) => Context.unsafeGet(env, current)) as Primitive
-              break
-            }
-            case "Left": {
-              curr = fail(current.left) as Primitive
-              break
-            }
-            case "None": {
-              curr = fail(new Cause.NoSuchElementException()) as Primitive
-              break
-            }
-            case "Right": {
-              curr = succeed(current.right) as Primitive
-              break
-            }
-            case "Some": {
-              curr = succeed(current.value) as Primitive
-              break
-            }
-            case "Commit": {
-              switch (current.effect_instruction_i0) {
-                case OpCodes.OP_DIE: {
-                  exit = TExit.die(internalCall(() => current.effect_instruction_i1()))
-                  break
-                }
-                case OpCodes.OP_FAIL: {
-                  const cont = this.nextFailure()
-                  if (cont === undefined) {
-                    exit = TExit.fail(internalCall(() => current.effect_instruction_i1()))
-                  } else {
-                    curr = internalCall(() =>
-                      cont.effect_instruction_i2(
-                        internalCall(() => current.effect_instruction_i1())
-                      ) as Primitive
-                    )
-                  }
-                  break
-                }
-                case OpCodes.OP_RETRY: {
-                  const cont = this.nextRetry()
-                  if (cont === undefined) {
-                    exit = TExit.retry
-                  } else {
-                    curr = internalCall(() => cont.effect_instruction_i2() as Primitive)
-                  }
-                  break
-                }
-                case OpCodes.OP_INTERRUPT: {
-                  exit = TExit.interrupt(this.fiberId)
-                  break
-                }
-                case OpCodes.OP_WITH_STM_RUNTIME: {
-                  curr = internalCall(() =>
-                    current.effect_instruction_i1(this as STMDriver<unknown, unknown, unknown>) as Primitive
-                  )
-                  break
-                }
-                case OpCodes.OP_ON_SUCCESS:
-                case OpCodes.OP_ON_FAILURE:
-                case OpCodes.OP_ON_RETRY: {
-                  this.pushStack(current)
-                  curr = current.effect_instruction_i1 as Primitive
-                  break
-                }
-                case OpCodes.OP_PROVIDE: {
-                  const env = this.env
-                  this.env = internalCall(() => current.effect_instruction_i2(env))
-                  curr = pipe(
-                    current.effect_instruction_i1,
-                    ensuring(sync(() => (this.env = env)))
-                  ) as Primitive
-                  break
-                }
-                case OpCodes.OP_SUCCEED: {
-                  const value = current.effect_instruction_i1
-                  const cont = this.nextSuccess()
-                  if (cont === undefined) {
-                    exit = TExit.succeed(value)
-                  } else {
-                    curr = internalCall(() => cont.effect_instruction_i2(value) as Primitive)
-                  }
-                  break
-                }
-                case OpCodes.OP_SYNC: {
-                  const value = internalCall(() => current.effect_instruction_i1())
-                  const cont = this.nextSuccess()
-                  if (cont === undefined) {
-                    exit = TExit.succeed(value)
-                  } else {
-                    curr = internalCall(() => cont.effect_instruction_i2(value) as Primitive)
-                  }
-                  break
-                }
-              }
-              break
-            }
-          }
-        }
-      } catch (e) {
-        curr = die(e) as Primitive
-      }
-    }
-    return exit as TExit.TExit<A, E>
-  }
-}
-
-/** @internal */
-export const catchAll = dual<
-  <E, B, E1, R1>(
-    f: (e: E) => STM.STM<B, E1, R1>
-  ) => <A, R>(
-    self: STM.STM<A, E, R>
-  ) => STM.STM<B | A, E1, R1 | R>,
-  <A, E, R, B, E1, R1>(
-    self: STM.STM<A, E, R>,
-    f: (e: E) => STM.STM<B, E1, R1>
-  ) => STM.STM<B | A, E1, R1 | R>
->(2, (self, f) => {
-  const stm = new STMPrimitive(OpCodes.OP_ON_FAILURE)
-  stm.effect_instruction_i1 = self
-  stm.effect_instruction_i2 = f
-  return stm
-})
-
-/** @internal */
-export const mapInputContext = dual<
-  <R0, R>(
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => <A, E>(
-    self: STM.STM<A, E, R>
-  ) => STM.STM<A, E, R0>,
-  <A, E, R0, R>(
-    self: STM.STM<A, E, R>,
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => STM.STM<A, E, R0>
->(2, (self, f) => {
-  const stm = new STMPrimitive(OpCodes.OP_PROVIDE)
-  stm.effect_instruction_i1 = self
-  stm.effect_instruction_i2 = f
-  return stm
-})
-
-/** @internal */
-export const die = (defect: unknown): STM.STM<never> => dieSync(() => defect)
-
-/** @internal */
-export const dieMessage = (message: string): STM.STM<never> => dieSync(() => new Cause.RuntimeException(message))
-
-/** @internal */
-export const dieSync = (evaluate: LazyArg<unknown>): STM.STM<never> => {
-  const stm = new STMPrimitive(OpCodes.OP_DIE)
-  stm.effect_instruction_i1 = evaluate
-  return stm as any
-}
-
-/** @internal */
-export const effect = <R, A>(
-  f: (journal: Journal.Journal, fiberId: FiberId.FiberId, environment: Context.Context<R>) => A
-): STM.STM<A, never, R> => withSTMRuntime((_) => succeed(f(_.journal, _.fiberId, _.getEnv())))
-
-/** @internal */
-export const ensuring = dual<
-  <R1, B>(finalizer: STM.STM<B, never, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R1 | R>,
-  <A, E, R, R1, B>(self: STM.STM<A, E, R>, finalizer: STM.STM<B, never, R1>) => STM.STM<A, E, R1 | R>
->(2, (self, finalizer) =>
-  matchSTM(self, {
-    onFailure: (e) => zipRight(finalizer, fail(e)),
-    onSuccess: (a) => zipRight(finalizer, succeed(a))
-  }))
-
-/** @internal */
-export const fail = <E>(error: E): STM.STM<never, E> => failSync(() => error)
-
-/** @internal */
-export const failSync = <E>(evaluate: LazyArg<E>): STM.STM<never, E> => {
-  const stm = new STMPrimitive(OpCodes.OP_FAIL)
-  stm.effect_instruction_i1 = evaluate
-  return stm as any
-}
-
-/** @internal */
-export const flatMap = dual<
-  <A, A2, E1, R1>(f: (a: A) => STM.STM<A2, E1, R1>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A2, E1 | E, R1 | R>,
-  <A, E, R, A2, E1, R1>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<A2, E1, R1>) => STM.STM<A2, E1 | E, R1 | R>
->(2, (self, f) => {
-  const stm = new STMPrimitive(OpCodes.OP_ON_SUCCESS)
-  stm.effect_instruction_i1 = self
-  stm.effect_instruction_i2 = f
-  return stm
-})
-
-/** @internal */
-export const matchSTM = dual<
-  <E, A1, E1, R1, A, A2, E2, R2>(
-    options: {
-      readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
-      readonly onSuccess: (a: A) => STM.STM<A2, E2, R2>
-    }
-  ) => <R>(self: STM.STM<A, E, R>) => STM.STM<A1 | A2, E1 | E2, R1 | R2 | R>,
-  <A, E, R, A1, E1, R1, A2, E2, R2>(
-    self: STM.STM<A, E, R>,
-    options: {
-      readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
-      readonly onSuccess: (a: A) => STM.STM<A2, E2, R2>
-    }
-  ) => STM.STM<A1 | A2, E1 | E2, R1 | R2 | R>
->(2, <A, E, R, A1, E1, R1, A2, E2, R2>(
-  self: STM.STM<A, E, R>,
-  { onFailure, onSuccess }: {
-    readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
-    readonly onSuccess: (a: A) => STM.STM<A2, E2, R2>
-  }
-): STM.STM<A1 | A2, E1 | E2, R1 | R2 | R> =>
-  pipe(
-    self,
-    map(Either.right),
-    catchAll((e) => pipe(onFailure(e), map(Either.left))),
-    flatMap((either): STM.STM<A1 | A2, E1 | E2, R | R1 | R2> => {
-      switch (either._tag) {
-        case "Left": {
-          return succeed(either.left)
-        }
-        case "Right": {
-          return onSuccess(either.right)
-        }
-      }
-    })
-  ))
-
-/** @internal */
-export const withSTMRuntime = <A, E = never, R = never>(
-  f: (runtime: STMDriver<unknown, unknown, unknown>) => STM.STM<A, E, R>
-): STM.STM<A, E, R> => {
-  const stm = new STMPrimitive(OpCodes.OP_WITH_STM_RUNTIME)
-  stm.effect_instruction_i1 = f
-  return stm
-}
-
-/** @internal */
-export const interrupt: STM.STM<never> = withSTMRuntime((_) => {
-  const stm = new STMPrimitive(OpCodes.OP_INTERRUPT)
-  stm.effect_instruction_i1 = _.fiberId
-  return stm as any
-})
-
-/** @internal */
-export const interruptAs = (fiberId: FiberId.FiberId): STM.STM<never> => {
-  const stm = new STMPrimitive(OpCodes.OP_INTERRUPT)
-  stm.effect_instruction_i1 = fiberId
-  return stm as any
-}
-
-/** @internal */
-export const map = dual<
-  <A, B>(f: (a: A) => B) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>,
-  <A, E, R, B>(self: STM.STM<A, E, R>, f: (a: A) => B) => STM.STM<B, E, R>
->(2, (self, f) => pipe(self, flatMap((a) => sync(() => f(a)))))
-
-/** @internal */
-export const orTry = dual<
-  <A1, E1, R1>(
-    that: LazyArg<STM.STM<A1, E1, R1>>
-  ) => <A, E, R>(
-    self: STM.STM<A, E, R>
-  ) => STM.STM<A1 | A, E1 | E, R1 | R>,
-  <A, E, R, A1, E1, R1>(
-    self: STM.STM<A, E, R>,
-    that: LazyArg<STM.STM<A1, E1, R1>>
-  ) => STM.STM<A1 | A, E1 | E, R1 | R>
->(2, (self, that) => {
-  const stm = new STMPrimitive(OpCodes.OP_ON_RETRY)
-  stm.effect_instruction_i1 = self
-  stm.effect_instruction_i2 = that
-  return stm
-})
-
-/** @internal */
-export const retry: STM.STM<never> = new STMPrimitive(OpCodes.OP_RETRY)
-
-/** @internal */
-export const succeed = <A>(value: A): STM.STM<A> => {
-  const stm = new STMPrimitive(OpCodes.OP_SUCCEED)
-  stm.effect_instruction_i1 = value
-  return stm as any
-}
-
-/** @internal */
-export const sync = <A>(evaluate: () => A): STM.STM<A> => {
-  const stm = new STMPrimitive(OpCodes.OP_SYNC)
-  stm.effect_instruction_i1 = evaluate
-  return stm as any
-}
-
-/** @internal */
-export const zip = dual<
-  <A1, E1, R1>(
-    that: STM.STM<A1, E1, R1>
-  ) => <A, E, R>(
-    self: STM.STM<A, E, R>
-  ) => STM.STM<[A, A1], E1 | E, R1 | R>,
-  <A, E, R, A1, E1, R1>(
-    self: STM.STM<A, E, R>,
-    that: STM.STM<A1, E1, R1>
-  ) => STM.STM<[A, A1], E1 | E, R1 | R>
->(2, (self, that) => pipe(self, zipWith(that, (a, a1) => [a, a1])))
-
-/** @internal */
-export const zipLeft = dual<
-  <A1, E1, R1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E1 | E, R1 | R>,
-  <A, E, R, A1, E1, R1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A, E1 | E, R1 | R>
->(2, (self, that) => pipe(self, flatMap((a) => pipe(that, map(() => a)))))
-
-/** @internal */
-export const zipRight = dual<
-  <A1, E1, R1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A1, E1 | E, R1 | R>,
-  <A, E, R, A1, E1, R1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A1, E1 | E, R1 | R>
->(2, (self, that) => pipe(self, flatMap(() => that)))
-
-/** @internal */
-export const zipWith = dual<
-  <A1, E1, R1, A, A2>(
-    that: STM.STM<A1, E1, R1>,
-    f: (a: A, b: A1) => A2
-  ) => <E, R>(
-    self: STM.STM<A, E, R>
-  ) => STM.STM<A2, E1 | E, R1 | R>,
-  <A, E, R, A1, E1, R1, A2>(
-    self: STM.STM<A, E, R>,
-    that: STM.STM<A1, E1, R1>,
-    f: (a: A, b: A1) => A2
-  ) => STM.STM<A2, E1 | E, R1 | R>
->(
-  3,
-  (self, that, f) => pipe(self, flatMap((a) => pipe(that, map((b) => f(a, b)))))
-)