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

package/src/internal/stm/core.ts

@@ -0,0 +1,817 @@
+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)))))
+)