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

package/src/internal/channel/channelState.ts

@@ -0,0 +1,134 @@
+import * as Effect from "../../Effect.js"
+import type * as Exit from "../../Exit.js"
+import { hasProperty } from "../../Predicate.js"
+import type * as Types from "../../Types.js"
+import * as OpCodes from "../opCodes/channelState.js"
+import type { ErasedExecutor } from "./channelExecutor.js"
+
+/** @internal */
+export const ChannelStateTypeId = Symbol.for("effect/ChannelState")
+
+/** @internal */
+export type ChannelStateTypeId = typeof ChannelStateTypeId
+
+/** @internal */
+export interface ChannelState<out E, out R> extends ChannelState.Variance<E, R> {}
+
+/** @internal */
+export declare namespace ChannelState {
+  export interface Variance<out E, out R> {
+    readonly [ChannelStateTypeId]: {
+      readonly _E: Types.Covariant<E>
+      readonly _R: Types.Covariant<R>
+    }
+  }
+}
+
+const channelStateVariance = {
+  /* c8 ignore next */
+  _E: (_: never) => _,
+  /* c8 ignore next */
+  _R: (_: 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>
+    onEffect(effect: Effect.Effect<void, never, unknown>): Effect.Effect<void, never, unknown>
+    onEmit(value: unknown): Effect.Effect<void, never, unknown>
+    onDone(exit: Exit.Exit<unknown, unknown>): Effect.Effect<void, never, unknown>
+  }>
+{}
+
+/** @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 = <X, E, R>(effect: Effect.Effect<X, E, R>): ChannelState<E, R> => {
+  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<void, never, R>) => Effect.Effect<void, never, R>,
+  onEmit: (value: unknown) => Effect.Effect<void, never, R> | undefined,
+  onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R> | undefined
+): ChannelState<never, R> => {
+  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> => hasProperty(u, ChannelStateTypeId)
+
+/** @internal */
+export const isDone = <E, R>(self: ChannelState<E, R>): self is Done => (self as Primitive)._tag === OpCodes.OP_DONE
+
+/** @internal */
+export const isEmit = <E, R>(self: ChannelState<E, R>): self is Emit => (self as Primitive)._tag === OpCodes.OP_EMIT
+
+/** @internal */
+export const isFromEffect = <E, R>(self: ChannelState<E, R>): self is FromEffect =>
+  (self as Primitive)._tag === OpCodes.OP_FROM_EFFECT
+
+/** @internal */
+export const isRead = <E, R>(self: ChannelState<E, R>): self is Read => (self as Primitive)._tag === OpCodes.OP_READ
+
+/** @internal */
+export const effect = <E, R>(self: ChannelState<E, R>): Effect.Effect<void, E, R> =>
+  isFromEffect(self) ? self.effect as Effect.Effect<void, E, R> : Effect.void
+
+/** @internal */
+export const effectOrUndefinedIgnored = <E, R>(self: ChannelState<E, R>): Effect.Effect<void, E, R> | undefined =>
+  isFromEffect(self) ? Effect.ignore(self.effect as Effect.Effect<void, E, R>) : undefined

package/src/internal/channel/childExecutorDecision.ts

@@ -0,0 +1,96 @@
+import type * as ChildExecutorDecision from "../../ChildExecutorDecision.js"
+import { dual } from "../../Function.js"
+import { hasProperty } from "../../Predicate.js"
+import * as OpCodes from "../opCodes/channelChildExecutorDecision.js"
+
+/** @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 =>
+  hasProperty(u, ChildExecutorDecisionTypeId)
+
+/** @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,200 @@
+import type * as Cause from "../../Cause.js"
+import type * as Channel from "../../Channel.js"
+import type * as Effect from "../../Effect.js"
+import * as Exit from "../../Exit.js"
+import type * as Types from "../../Types.js"
+import * as OpCodes from "../opCodes/continuation.js"
+
+/** @internal */
+export const ContinuationTypeId = Symbol.for("effect/ChannelContinuation")
+
+/** @internal */
+export type ContinuationTypeId = typeof ContinuationTypeId
+
+/** @internal */
+export interface Continuation<
+  out Env,
+  in InErr,
+  in InElem,
+  in InDone,
+  out OutErr,
+  out OutErr2,
+  out OutElem,
+  out OutDone,
+  out OutDone2
+> extends Continuation.Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {}
+
+/** @internal */
+export declare namespace Continuation {
+  /** @internal */
+  export interface Variance<
+    out Env,
+    in InErr,
+    in InElem,
+    in InDone,
+    out OutErr,
+    out OutErr2,
+    out OutElem,
+    out OutDone,
+    out OutDone2
+  > {
+    readonly [ContinuationTypeId]: {
+      readonly _Env: Types.Covariant<Env>
+      readonly _InErr: Types.Contravariant<InErr>
+      readonly _InElem: Types.Contravariant<InElem>
+      readonly _InDone: Types.Contravariant<InDone>
+      readonly _OutErr: Types.Covariant<OutErr>
+      readonly _OutDone: Types.Covariant<OutDone>
+      readonly _OutErr2: Types.Covariant<OutErr2>
+      readonly _OutElem: Types.Covariant<OutElem>
+      readonly _OutDone2: Types.Covariant<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<
+  out Env,
+  in InErr,
+  in InElem,
+  in InDone,
+  out OutErr,
+  out OutErr2,
+  out OutElem,
+  out OutDone,
+  out OutDone2
+> extends
+  Continuation<
+    Env,
+    InErr,
+    InElem,
+    InDone,
+    OutErr,
+    OutErr2,
+    OutElem,
+    OutDone,
+    OutDone2
+  >
+{
+  readonly _tag: OpCodes.OP_CONTINUATION_K
+  onSuccess(
+    o: OutDone
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
+  onHalt(
+    c: Cause.Cause<OutErr>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
+  onExit(
+    exit: Exit.Exit<OutDone, OutErr>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
+}
+
+/** @internal */
+export interface ContinuationFinalizer<out Env, out OutErr, out OutDone> extends
+  Continuation<
+    Env,
+    unknown,
+    unknown,
+    unknown,
+    OutErr,
+    never,
+    never,
+    OutDone,
+    never
+  >
+{
+  readonly _tag: OpCodes.OP_CONTINUATION_FINALIZER
+  finalizer(exit: Exit.Exit<OutErr, OutDone>): Effect.Effect<unknown, never, Env>
+}
+
+const continuationVariance = {
+  /* c8 ignore next */
+  _Env: (_: never) => _,
+  /* c8 ignore next */
+  _InErr: (_: unknown) => _,
+  /* c8 ignore next */
+  _InElem: (_: unknown) => _,
+  /* c8 ignore next */
+  _InDone: (_: unknown) => _,
+  /* c8 ignore next */
+  _OutErr: (_: never) => _,
+  /* c8 ignore next */
+  _OutDone: (_: never) => _,
+  /* c8 ignore next */
+  _OutErr2: (_: never) => _,
+  /* c8 ignore next */
+  _OutElem: (_: never) => _,
+  /* c8 ignore next */
+  _OutDone2: (_: never) => _
+}
+
+/** @internal */
+export class ContinuationKImpl<
+  out Env,
+  out Env2,
+  in InErr,
+  in InElem,
+  in InDone,
+  in out OutErr,
+  out OutErr2,
+  out OutElem,
+  in out OutDone,
+  out 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<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>,
+    readonly onHalt: (
+      c: Cause.Cause<OutErr>
+    ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
+  ) {
+  }
+  onExit(
+    exit: Exit.Exit<OutDone, OutErr>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env | Env2> {
+    return Exit.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value)
+  }
+}
+
+/** @internal */
+export class ContinuationFinalizerImpl<out Env, in out OutErr, in out 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<unknown, never, Env>) {
+  }
+}

package/src/internal/channel/mergeDecision.ts

@@ -0,0 +1,113 @@
+import type * as Effect from "../../Effect.js"
+import type * as Exit from "../../Exit.js"
+import { dual } from "../../Function.js"
+import type * as MergeDecision from "../../MergeDecision.js"
+import { hasProperty } from "../../Predicate.js"
+import * as OpCodes from "../opCodes/channelMergeDecision.js"
+
+/** @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>
+  }>
+{}
+
+/** @internal */
+export interface Await extends
+  Op<OpCodes.OP_AWAIT, {
+    f(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never>
+  }>
+{}
+
+/** @internal */
+export const Done = <Z, E, R>(
+  effect: Effect.Effect<Z, E, R>
+): 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<Z0, E0>) => Effect.Effect<Z, E, R>
+): 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 = <Z, E, R>(
+  effect: Effect.Effect<Z, E, R>
+): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => Await(() => effect)
+
+/** @internal */
+export const isMergeDecision = (
+  u: unknown
+): u is MergeDecision.MergeDecision<unknown, unknown, unknown, unknown, unknown> => hasProperty(u, MergeDecisionTypeId)
+
+/** @internal */
+export const match = dual<
+  <R, E0, Z0, E, Z, Z2>(
+    options: {
+      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => 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<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
+    }
+  ) => Z2
+>(2, <R, E0, Z0, E, Z, Z2>(
+  self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>,
+  { onAwait, onDone }: {
+    readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+    readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => 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 Effect from "../../Effect.js"
+import type * as Either from "../../Either.js"
+import type * as Exit from "../../Exit.js"
+import type * as Fiber from "../../Fiber.js"
+import { dual } from "../../Function.js"
+import type * as MergeState from "../../MergeState.js"
+import { hasProperty } from "../../Predicate.js"
+import * as OpCodes from "../opCodes/channelMergeState.js"
+
+/** @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<Either.Either<Elem, Done>, Err>,
+  right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
+): 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<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>
+): 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<Done, Err>) => Effect.Effect<Done2, Err2, Env>
+): 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> =>
+  hasProperty(u, MergeStateTypeId)
+
+/** @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<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => 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<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => 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)
+    }
+  }
+})