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

package/src/internal/cause.ts

@@ -1,1050 +0,0 @@
-import * as Arr from "../Array.js"
-import type * as Cause from "../Cause.js"
-import * as Chunk from "../Chunk.js"
-import * as Either from "../Either.js"
-import * as Equal from "../Equal.js"
-import type * as FiberId from "../FiberId.js"
-import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
-import * as Hash from "../Hash.js"
-import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, stringifyCircular, toJSON } from "../Inspectable.js"
-import * as Option from "../Option.js"
-import { pipeArguments } from "../Pipeable.js"
-import type { Predicate, Refinement } from "../Predicate.js"
-import { hasProperty, isFunction } from "../Predicate.js"
-import type { AnySpan, Span } from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
-import { getBugErrorMessage } from "./errors.js"
-import * as OpCodes from "./opCodes/cause.js"
-
-// -----------------------------------------------------------------------------
-// Models
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const CauseSymbolKey = "effect/Cause"
-
-/** @internal */
-export const CauseTypeId: Cause.CauseTypeId = Symbol.for(
-  CauseSymbolKey
-) as Cause.CauseTypeId
-
-const variance = {
-  /* c8 ignore next */
-  _E: (_: never) => _
-}
-
-/** @internal */
-const proto = {
-  [CauseTypeId]: variance,
-  [Hash.symbol](this: Cause.Cause<any>): number {
-    return pipe(
-      Hash.hash(CauseSymbolKey),
-      Hash.combine(Hash.hash(flattenCause(this))),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](this: Cause.Cause<any>, that: unknown): boolean {
-    return isCause(that) && causeEquals(this, that)
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  toJSON<E>(this: Cause.Cause<E>) {
-    switch (this._tag) {
-      case "Empty":
-        return { _id: "Cause", _tag: this._tag }
-      case "Die":
-        return { _id: "Cause", _tag: this._tag, defect: toJSON(this.defect) }
-      case "Interrupt":
-        return { _id: "Cause", _tag: this._tag, fiberId: this.fiberId.toJSON() }
-      case "Fail":
-        return { _id: "Cause", _tag: this._tag, failure: toJSON(this.error) }
-      case "Sequential":
-      case "Parallel":
-        return { _id: "Cause", _tag: this._tag, left: toJSON(this.left), right: toJSON(this.right) }
-    }
-  },
-  toString<E>(this: Cause.Cause<E>) {
-    return pretty(this)
-  },
-  [NodeInspectSymbol]<E>(this: Cause.Cause<E>) {
-    return this.toJSON()
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Constructors
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const empty: Cause.Cause<never> = (() => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_EMPTY
-  return o
-})()
-
-/** @internal */
-export const fail = <E>(error: E): Cause.Cause<E> => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_FAIL
-  o.error = error
-  return o
-}
-
-/** @internal */
-export const die = (defect: unknown): Cause.Cause<never> => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_DIE
-  o.defect = defect
-  return o
-}
-
-/** @internal */
-export const interrupt = (fiberId: FiberId.FiberId): Cause.Cause<never> => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_INTERRUPT
-  o.fiberId = fiberId
-  return o
-}
-
-/** @internal */
-export const parallel = <E, E2>(left: Cause.Cause<E>, right: Cause.Cause<E2>): Cause.Cause<E | E2> => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_PARALLEL
-  o.left = left
-  o.right = right
-  return o
-}
-
-/** @internal */
-export const sequential = <E, E2>(left: Cause.Cause<E>, right: Cause.Cause<E2>): Cause.Cause<E | E2> => {
-  const o = Object.create(proto)
-  o._tag = OpCodes.OP_SEQUENTIAL
-  o.left = left
-  o.right = right
-  return o
-}
-
-// -----------------------------------------------------------------------------
-// Refinements
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const isCause = (u: unknown): u is Cause.Cause<unknown> => hasProperty(u, CauseTypeId)
-
-/** @internal */
-export const isEmptyType = <E>(self: Cause.Cause<E>): self is Cause.Empty => self._tag === OpCodes.OP_EMPTY
-
-/** @internal */
-export const isFailType = <E>(self: Cause.Cause<E>): self is Cause.Fail<E> => self._tag === OpCodes.OP_FAIL
-
-/** @internal */
-export const isDieType = <E>(self: Cause.Cause<E>): self is Cause.Die => self._tag === OpCodes.OP_DIE
-
-/** @internal */
-export const isInterruptType = <E>(self: Cause.Cause<E>): self is Cause.Interrupt => self._tag === OpCodes.OP_INTERRUPT
-
-/** @internal */
-export const isSequentialType = <E>(self: Cause.Cause<E>): self is Cause.Sequential<E> =>
-  self._tag === OpCodes.OP_SEQUENTIAL
-
-/** @internal */
-export const isParallelType = <E>(self: Cause.Cause<E>): self is Cause.Parallel<E> => self._tag === OpCodes.OP_PARALLEL
-
-// -----------------------------------------------------------------------------
-// Getters
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const size = <E>(self: Cause.Cause<E>): number => reduceWithContext(self, void 0, SizeCauseReducer)
-
-/** @internal */
-export const isEmpty = <E>(self: Cause.Cause<E>): boolean => {
-  if (self._tag === OpCodes.OP_EMPTY) {
-    return true
-  }
-  return reduce(self, true, (acc, cause) => {
-    switch (cause._tag) {
-      case OpCodes.OP_EMPTY: {
-        return Option.some(acc)
-      }
-      case OpCodes.OP_DIE:
-      case OpCodes.OP_FAIL:
-      case OpCodes.OP_INTERRUPT: {
-        return Option.some(false)
-      }
-      default: {
-        return Option.none()
-      }
-    }
-  })
-}
-
-/** @internal */
-export const isFailure = <E>(self: Cause.Cause<E>): boolean => Option.isSome(failureOption(self))
-
-/** @internal */
-export const isDie = <E>(self: Cause.Cause<E>): boolean => Option.isSome(dieOption(self))
-
-/** @internal */
-export const isInterrupted = <E>(self: Cause.Cause<E>): boolean => Option.isSome(interruptOption(self))
-
-/** @internal */
-export const isInterruptedOnly = <E>(self: Cause.Cause<E>): boolean =>
-  reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self)
-
-/** @internal */
-export const failures = <E>(self: Cause.Cause<E>): Chunk.Chunk<E> =>
-  Chunk.reverse(
-    reduce<Chunk.Chunk<E>, E>(
-      self,
-      Chunk.empty<E>(),
-      (list, cause) =>
-        cause._tag === OpCodes.OP_FAIL ?
-          Option.some(pipe(list, Chunk.prepend(cause.error))) :
-          Option.none()
-    )
-  )
-
-/** @internal */
-export const defects = <E>(self: Cause.Cause<E>): Chunk.Chunk<unknown> =>
-  Chunk.reverse(
-    reduce<Chunk.Chunk<unknown>, E>(
-      self,
-      Chunk.empty<unknown>(),
-      (list, cause) =>
-        cause._tag === OpCodes.OP_DIE ?
-          Option.some(pipe(list, Chunk.prepend(cause.defect))) :
-          Option.none()
-    )
-  )
-
-/** @internal */
-export const interruptors = <E>(self: Cause.Cause<E>): HashSet.HashSet<FiberId.FiberId> =>
-  reduce(self, HashSet.empty<FiberId.FiberId>(), (set, cause) =>
-    cause._tag === OpCodes.OP_INTERRUPT ?
-      Option.some(pipe(set, HashSet.add(cause.fiberId))) :
-      Option.none())
-
-/** @internal */
-export const failureOption = <E>(self: Cause.Cause<E>): Option.Option<E> =>
-  find<E, E>(self, (cause) =>
-    cause._tag === OpCodes.OP_FAIL ?
-      Option.some(cause.error) :
-      Option.none())
-
-/** @internal */
-export const failureOrCause = <E>(self: Cause.Cause<E>): Either.Either<Cause.Cause<never>, E> => {
-  const option = failureOption(self)
-  switch (option._tag) {
-    case "None": {
-      // no `E` inside this `Cause`, so it can be safely cast to `never`
-      return Either.right(self as Cause.Cause<never>)
-    }
-    case "Some": {
-      return Either.left(option.value)
-    }
-  }
-}
-
-/** @internal */
-export const dieOption = <E>(self: Cause.Cause<E>): Option.Option<unknown> =>
-  find(self, (cause) =>
-    cause._tag === OpCodes.OP_DIE ?
-      Option.some(cause.defect) :
-      Option.none())
-
-/** @internal */
-export const flipCauseOption = <E>(self: Cause.Cause<Option.Option<E>>): Option.Option<Cause.Cause<E>> =>
-  match(self, {
-    onEmpty: Option.some<Cause.Cause<E>>(empty),
-    onFail: Option.map(fail),
-    onDie: (defect) => Option.some(die(defect)),
-    onInterrupt: (fiberId) => Option.some(interrupt(fiberId)),
-    onSequential: Option.mergeWith(sequential),
-    onParallel: Option.mergeWith(parallel)
-  })
-
-/** @internal */
-export const interruptOption = <E>(self: Cause.Cause<E>): Option.Option<FiberId.FiberId> =>
-  find(self, (cause) =>
-    cause._tag === OpCodes.OP_INTERRUPT ?
-      Option.some(cause.fiberId) :
-      Option.none())
-
-/** @internal */
-export const keepDefects = <E>(self: Cause.Cause<E>): Option.Option<Cause.Cause<never>> =>
-  match(self, {
-    onEmpty: Option.none(),
-    onFail: () => Option.none(),
-    onDie: (defect) => Option.some(die(defect)),
-    onInterrupt: () => Option.none(),
-    onSequential: Option.mergeWith(sequential),
-    onParallel: Option.mergeWith(parallel)
-  })
-
-/** @internal */
-export const keepDefectsAndElectFailures = <E>(self: Cause.Cause<E>): Option.Option<Cause.Cause<never>> =>
-  match(self, {
-    onEmpty: Option.none(),
-    onFail: (failure) => Option.some(die(failure)),
-    onDie: (defect) => Option.some(die(defect)),
-    onInterrupt: () => Option.none(),
-    onSequential: Option.mergeWith(sequential),
-    onParallel: Option.mergeWith(parallel)
-  })
-
-/** @internal */
-export const linearize = <E>(self: Cause.Cause<E>): HashSet.HashSet<Cause.Cause<E>> =>
-  match(self, {
-    onEmpty: HashSet.empty(),
-    onFail: (error) => HashSet.make(fail(error)),
-    onDie: (defect) => HashSet.make(die(defect)),
-    onInterrupt: (fiberId) => HashSet.make(interrupt(fiberId)),
-    onSequential: (leftSet, rightSet) =>
-      HashSet.flatMap(leftSet, (leftCause) => HashSet.map(rightSet, (rightCause) => sequential(leftCause, rightCause))),
-    onParallel: (leftSet, rightSet) =>
-      HashSet.flatMap(leftSet, (leftCause) => HashSet.map(rightSet, (rightCause) => parallel(leftCause, rightCause)))
-  })
-
-/** @internal */
-export const stripFailures = <E>(self: Cause.Cause<E>): Cause.Cause<never> =>
-  match(self, {
-    onEmpty: empty,
-    onFail: () => empty,
-    onDie: die,
-    onInterrupt: interrupt,
-    onSequential: sequential,
-    onParallel: parallel
-  })
-
-/** @internal */
-export const electFailures = <E>(self: Cause.Cause<E>): Cause.Cause<never> =>
-  match(self, {
-    onEmpty: empty,
-    onFail: die,
-    onDie: die,
-    onInterrupt: interrupt,
-    onSequential: sequential,
-    onParallel: parallel
-  })
-
-/** @internal */
-export const stripSomeDefects = dual<
-  (pf: (defect: unknown) => Option.Option<unknown>) => <E>(self: Cause.Cause<E>) => Option.Option<Cause.Cause<E>>,
-  <E>(self: Cause.Cause<E>, pf: (defect: unknown) => Option.Option<unknown>) => Option.Option<Cause.Cause<E>>
->(
-  2,
-  <E>(self: Cause.Cause<E>, pf: (defect: unknown) => Option.Option<unknown>): Option.Option<Cause.Cause<E>> =>
-    match(self, {
-      onEmpty: Option.some<Cause.Cause<E>>(empty),
-      onFail: (error) => Option.some(fail(error)),
-      onDie: (defect) => {
-        const option = pf(defect)
-        return Option.isSome(option) ? Option.none() : Option.some(die(defect))
-      },
-      onInterrupt: (fiberId) => Option.some(interrupt(fiberId)),
-      onSequential: Option.mergeWith(sequential),
-      onParallel: Option.mergeWith(parallel)
-    })
-)
-
-// -----------------------------------------------------------------------------
-// Mapping
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const as = dual<
-  <E2>(error: E2) => <E>(self: Cause.Cause<E>) => Cause.Cause<E2>,
-  <E, E2>(self: Cause.Cause<E>, error: E2) => Cause.Cause<E2>
->(2, (self, error) => map(self, () => error))
-
-/** @internal */
-export const map = dual<
-  <E, E2>(f: (e: E) => E2) => (self: Cause.Cause<E>) => Cause.Cause<E2>,
-  <E, E2>(self: Cause.Cause<E>, f: (e: E) => E2) => Cause.Cause<E2>
->(2, (self, f) => flatMap(self, (e) => fail(f(e))))
-
-// -----------------------------------------------------------------------------
-// Sequencing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const flatMap = dual<
-  <E, E2>(f: (e: E) => Cause.Cause<E2>) => (self: Cause.Cause<E>) => Cause.Cause<E2>,
-  <E, E2>(self: Cause.Cause<E>, f: (e: E) => Cause.Cause<E2>) => Cause.Cause<E2>
->(2, (self, f) =>
-  match(self, {
-    onEmpty: empty,
-    onFail: (error) => f(error),
-    onDie: (defect) => die(defect),
-    onInterrupt: (fiberId) => interrupt(fiberId),
-    onSequential: (left, right) => sequential(left, right),
-    onParallel: (left, right) => parallel(left, right)
-  }))
-
-/** @internal */
-export const flatten = <E>(self: Cause.Cause<Cause.Cause<E>>): Cause.Cause<E> => flatMap(self, identity)
-
-/** @internal */
-export const andThen: {
-  <E, E2>(f: (e: E) => Cause.Cause<E2>): (self: Cause.Cause<E>) => Cause.Cause<E2>
-  <E2>(f: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E2>
-  <E, E2>(self: Cause.Cause<E>, f: (e: E) => Cause.Cause<E2>): Cause.Cause<E2>
-  <E, E2>(self: Cause.Cause<E>, f: Cause.Cause<E2>): Cause.Cause<E2>
-} = dual(
-  2,
-  <E, E2>(self: Cause.Cause<E>, f: ((e: E) => Cause.Cause<E2>) | Cause.Cause<E2>): Cause.Cause<E2> =>
-    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
-)
-
-// -----------------------------------------------------------------------------
-// Equality
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const contains = dual<
-  <E2>(that: Cause.Cause<E2>) => <E>(self: Cause.Cause<E>) => boolean,
-  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>) => boolean
->(2, (self, that) => {
-  if (that._tag === OpCodes.OP_EMPTY || self === that) {
-    return true
-  }
-  return reduce(self, false, (accumulator, cause) => {
-    return Option.some(accumulator || causeEquals(cause, that))
-  })
-})
-
-/** @internal */
-const causeEquals = (left: Cause.Cause<unknown>, right: Cause.Cause<unknown>): boolean => {
-  let leftStack: Chunk.Chunk<Cause.Cause<unknown>> = Chunk.of(left)
-  let rightStack: Chunk.Chunk<Cause.Cause<unknown>> = Chunk.of(right)
-  while (Chunk.isNonEmpty(leftStack) && Chunk.isNonEmpty(rightStack)) {
-    const [leftParallel, leftSequential] = pipe(
-      Chunk.headNonEmpty(leftStack),
-      reduce(
-        [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
-        ([parallel, sequential], cause) => {
-          const [par, seq] = evaluateCause(cause)
-          return Option.some(
-            [
-              pipe(parallel, HashSet.union(par)),
-              pipe(sequential, Chunk.appendAll(seq))
-            ] as const
-          )
-        }
-      )
-    )
-    const [rightParallel, rightSequential] = pipe(
-      Chunk.headNonEmpty(rightStack),
-      reduce(
-        [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
-        ([parallel, sequential], cause) => {
-          const [par, seq] = evaluateCause(cause)
-          return Option.some(
-            [
-              pipe(parallel, HashSet.union(par)),
-              pipe(sequential, Chunk.appendAll(seq))
-            ] as const
-          )
-        }
-      )
-    )
-    if (!Equal.equals(leftParallel, rightParallel)) {
-      return false
-    }
-    leftStack = leftSequential
-    rightStack = rightSequential
-  }
-  return true
-}
-
-// -----------------------------------------------------------------------------
-// Flattening
-// -----------------------------------------------------------------------------
-
-/**
- * Flattens a cause to a sequence of sets of causes, where each set represents
- * causes that fail in parallel and sequential sets represent causes that fail
- * after each other.
- *
- * @internal
- */
-const flattenCause = (cause: Cause.Cause<unknown>): Chunk.Chunk<HashSet.HashSet<unknown>> => {
-  return flattenCauseLoop(Chunk.of(cause), Chunk.empty())
-}
-
-/** @internal */
-const flattenCauseLoop = (
-  causes: Chunk.Chunk<Cause.Cause<unknown>>,
-  flattened: Chunk.Chunk<HashSet.HashSet<unknown>>
-): Chunk.Chunk<HashSet.HashSet<unknown>> => {
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = pipe(
-      causes,
-      Arr.reduce(
-        [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
-        ([parallel, sequential], cause) => {
-          const [par, seq] = evaluateCause(cause)
-          return [
-            pipe(parallel, HashSet.union(par)),
-            pipe(sequential, Chunk.appendAll(seq))
-          ]
-        }
-      )
-    )
-    const updated = HashSet.size(parallel) > 0 ?
-      pipe(flattened, Chunk.prepend(parallel)) :
-      flattened
-    if (Chunk.isEmpty(sequential)) {
-      return Chunk.reverse(updated)
-    }
-    causes = sequential
-    flattened = updated
-  }
-  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"))
-}
-
-// -----------------------------------------------------------------------------
-// Finding
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const find = dual<
-  <E, Z>(pf: (cause: Cause.Cause<E>) => Option.Option<Z>) => (self: Cause.Cause<E>) => Option.Option<Z>,
-  <E, Z>(self: Cause.Cause<E>, pf: (cause: Cause.Cause<E>) => Option.Option<Z>) => Option.Option<Z>
->(2, <E, Z>(self: Cause.Cause<E>, pf: (cause: Cause.Cause<E>) => Option.Option<Z>) => {
-  const stack: Array<Cause.Cause<E>> = [self]
-  while (stack.length > 0) {
-    const item = stack.pop()!
-    const option = pf(item)
-    switch (option._tag) {
-      case "None": {
-        switch (item._tag) {
-          case OpCodes.OP_SEQUENTIAL:
-          case OpCodes.OP_PARALLEL: {
-            stack.push(item.right)
-            stack.push(item.left)
-            break
-          }
-        }
-        break
-      }
-      case "Some": {
-        return option
-      }
-    }
-  }
-  return Option.none()
-})
-
-// -----------------------------------------------------------------------------
-// Filtering
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const filter: {
-  <E, EB extends E>(
-    refinement: Refinement<Cause.Cause<NoInfer<E>>, Cause.Cause<EB>>
-  ): (self: Cause.Cause<E>) => Cause.Cause<EB>
-  <E>(predicate: Predicate<Cause.Cause<NoInfer<E>>>): (self: Cause.Cause<E>) => Cause.Cause<E>
-  <E, EB extends E>(self: Cause.Cause<E>, refinement: Refinement<Cause.Cause<E>, Cause.Cause<EB>>): Cause.Cause<EB>
-  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E>
-} = dual(
-  2,
-  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E> =>
-    reduceWithContext(self, void 0, FilterCauseReducer(predicate))
-)
-
-// -----------------------------------------------------------------------------
-// Evaluation
-// -----------------------------------------------------------------------------
-
-/**
- * Takes one step in evaluating a cause, returning a set of causes that fail
- * in parallel and a list of causes that fail sequentially after those causes.
- *
- * @internal
- */
-const evaluateCause = (
-  self: Cause.Cause<unknown>
-): [HashSet.HashSet<unknown>, Chunk.Chunk<Cause.Cause<unknown>>] => {
-  let cause: Cause.Cause<unknown> | undefined = self
-  const stack: Array<Cause.Cause<unknown>> = []
-  let _parallel = HashSet.empty<unknown>()
-  let _sequential = Chunk.empty<Cause.Cause<unknown>>()
-  while (cause !== undefined) {
-    switch (cause._tag) {
-      case OpCodes.OP_EMPTY: {
-        if (stack.length === 0) {
-          return [_parallel, _sequential]
-        }
-        cause = stack.pop()
-        break
-      }
-      case OpCodes.OP_FAIL: {
-        _parallel = HashSet.add(_parallel, Chunk.make(cause._tag, cause.error))
-        if (stack.length === 0) {
-          return [_parallel, _sequential]
-        }
-        cause = stack.pop()
-        break
-      }
-      case OpCodes.OP_DIE: {
-        _parallel = HashSet.add(_parallel, Chunk.make(cause._tag, cause.defect))
-        if (stack.length === 0) {
-          return [_parallel, _sequential]
-        }
-        cause = stack.pop()
-        break
-      }
-      case OpCodes.OP_INTERRUPT: {
-        _parallel = HashSet.add(_parallel, Chunk.make(cause._tag, cause.fiberId as unknown))
-        if (stack.length === 0) {
-          return [_parallel, _sequential]
-        }
-        cause = stack.pop()
-        break
-      }
-      case OpCodes.OP_SEQUENTIAL: {
-        switch (cause.left._tag) {
-          case OpCodes.OP_EMPTY: {
-            cause = cause.right
-            break
-          }
-          case OpCodes.OP_SEQUENTIAL: {
-            cause = sequential(cause.left.left, sequential(cause.left.right, cause.right))
-            break
-          }
-          case OpCodes.OP_PARALLEL: {
-            cause = parallel(
-              sequential(cause.left.left, cause.right),
-              sequential(cause.left.right, cause.right)
-            )
-            break
-          }
-          default: {
-            _sequential = Chunk.prepend(_sequential, cause.right)
-            cause = cause.left
-            break
-          }
-        }
-        break
-      }
-      case OpCodes.OP_PARALLEL: {
-        stack.push(cause.right)
-        cause = cause.left
-        break
-      }
-    }
-  }
-  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"))
-}
-
-// -----------------------------------------------------------------------------
-// Reducing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const SizeCauseReducer: Cause.CauseReducer<unknown, unknown, number> = {
-  emptyCase: () => 0,
-  failCase: () => 1,
-  dieCase: () => 1,
-  interruptCase: () => 1,
-  sequentialCase: (_, left, right) => left + right,
-  parallelCase: (_, left, right) => left + right
-}
-
-/** @internal */
-const IsInterruptedOnlyCauseReducer: Cause.CauseReducer<unknown, unknown, boolean> = {
-  emptyCase: constTrue,
-  failCase: constFalse,
-  dieCase: constFalse,
-  interruptCase: constTrue,
-  sequentialCase: (_, left, right) => left && right,
-  parallelCase: (_, left, right) => left && right
-}
-
-/** @internal */
-const FilterCauseReducer = <E>(
-  predicate: Predicate<Cause.Cause<E>>
-): Cause.CauseReducer<unknown, E, Cause.Cause<E>> => ({
-  emptyCase: () => empty,
-  failCase: (_, error) => fail(error),
-  dieCase: (_, defect) => die(defect),
-  interruptCase: (_, fiberId) => interrupt(fiberId),
-  sequentialCase: (_, left, right) => {
-    if (predicate(left)) {
-      if (predicate(right)) {
-        return sequential(left, right)
-      }
-      return left
-    }
-    if (predicate(right)) {
-      return right
-    }
-    return empty
-  },
-  parallelCase: (_, left, right) => {
-    if (predicate(left)) {
-      if (predicate(right)) {
-        return parallel(left, right)
-      }
-      return left
-    }
-    if (predicate(right)) {
-      return right
-    }
-    return empty
-  }
-})
-
-/** @internal */
-type CauseCase = SequentialCase | ParallelCase
-
-const OP_SEQUENTIAL_CASE = "SequentialCase"
-
-const OP_PARALLEL_CASE = "ParallelCase"
-
-/** @internal */
-interface SequentialCase {
-  readonly _tag: typeof OP_SEQUENTIAL_CASE
-}
-
-/** @internal */
-interface ParallelCase {
-  readonly _tag: typeof OP_PARALLEL_CASE
-}
-
-/** @internal */
-export const match = dual<
-  <Z, E>(
-    options: {
-      readonly onEmpty: Z
-      readonly onFail: (error: E) => Z
-      readonly onDie: (defect: unknown) => Z
-      readonly onInterrupt: (fiberId: FiberId.FiberId) => Z
-      readonly onSequential: (left: Z, right: Z) => Z
-      readonly onParallel: (left: Z, right: Z) => Z
-    }
-  ) => (self: Cause.Cause<E>) => Z,
-  <Z, E>(
-    self: Cause.Cause<E>,
-    options: {
-      readonly onEmpty: Z
-      readonly onFail: (error: E) => Z
-      readonly onDie: (defect: unknown) => Z
-      readonly onInterrupt: (fiberId: FiberId.FiberId) => Z
-      readonly onSequential: (left: Z, right: Z) => Z
-      readonly onParallel: (left: Z, right: Z) => Z
-    }
-  ) => Z
->(2, (self, { onDie, onEmpty, onFail, onInterrupt, onParallel, onSequential }) => {
-  return reduceWithContext(self, void 0, {
-    emptyCase: () => onEmpty,
-    failCase: (_, error) => onFail(error),
-    dieCase: (_, defect) => onDie(defect),
-    interruptCase: (_, fiberId) => onInterrupt(fiberId),
-    sequentialCase: (_, left, right) => onSequential(left, right),
-    parallelCase: (_, left, right) => onParallel(left, right)
-  })
-})
-
-/** @internal */
-export const reduce = dual<
-  <Z, E>(zero: Z, pf: (accumulator: Z, cause: Cause.Cause<E>) => Option.Option<Z>) => (self: Cause.Cause<E>) => Z,
-  <Z, E>(self: Cause.Cause<E>, zero: Z, pf: (accumulator: Z, cause: Cause.Cause<E>) => Option.Option<Z>) => Z
->(3, <Z, E>(self: Cause.Cause<E>, zero: Z, pf: (accumulator: Z, cause: Cause.Cause<E>) => Option.Option<Z>) => {
-  let accumulator: Z = zero
-  let cause: Cause.Cause<E> | undefined = self
-  const causes: Array<Cause.Cause<E>> = []
-  while (cause !== undefined) {
-    const option = pf(accumulator, cause)
-    accumulator = Option.isSome(option) ? option.value : accumulator
-    switch (cause._tag) {
-      case OpCodes.OP_SEQUENTIAL: {
-        causes.push(cause.right)
-        cause = cause.left
-        break
-      }
-      case OpCodes.OP_PARALLEL: {
-        causes.push(cause.right)
-        cause = cause.left
-        break
-      }
-      default: {
-        cause = undefined
-        break
-      }
-    }
-    if (cause === undefined && causes.length > 0) {
-      cause = causes.pop()!
-    }
-  }
-  return accumulator
-})
-
-/** @internal */
-export const reduceWithContext = dual<
-  <C, E, Z>(context: C, reducer: Cause.CauseReducer<C, E, Z>) => (self: Cause.Cause<E>) => Z,
-  <C, E, Z>(self: Cause.Cause<E>, context: C, reducer: Cause.CauseReducer<C, E, Z>) => Z
->(3, <C, E, Z>(self: Cause.Cause<E>, context: C, reducer: Cause.CauseReducer<C, E, Z>) => {
-  const input: Array<Cause.Cause<E>> = [self]
-  const output: Array<Either.Either<Z, CauseCase>> = []
-  while (input.length > 0) {
-    const cause = input.pop()!
-    switch (cause._tag) {
-      case OpCodes.OP_EMPTY: {
-        output.push(Either.right(reducer.emptyCase(context)))
-        break
-      }
-      case OpCodes.OP_FAIL: {
-        output.push(Either.right(reducer.failCase(context, cause.error)))
-        break
-      }
-      case OpCodes.OP_DIE: {
-        output.push(Either.right(reducer.dieCase(context, cause.defect)))
-        break
-      }
-      case OpCodes.OP_INTERRUPT: {
-        output.push(Either.right(reducer.interruptCase(context, cause.fiberId)))
-        break
-      }
-      case OpCodes.OP_SEQUENTIAL: {
-        input.push(cause.right)
-        input.push(cause.left)
-        output.push(Either.left({ _tag: OP_SEQUENTIAL_CASE }))
-        break
-      }
-      case OpCodes.OP_PARALLEL: {
-        input.push(cause.right)
-        input.push(cause.left)
-        output.push(Either.left({ _tag: OP_PARALLEL_CASE }))
-        break
-      }
-    }
-  }
-  const accumulator: Array<Z> = []
-  while (output.length > 0) {
-    const either = output.pop()!
-    switch (either._tag) {
-      case "Left": {
-        switch (either.left._tag) {
-          case OP_SEQUENTIAL_CASE: {
-            const left = accumulator.pop()!
-            const right = accumulator.pop()!
-            const value = reducer.sequentialCase(context, left, right)
-            accumulator.push(value)
-            break
-          }
-          case OP_PARALLEL_CASE: {
-            const left = accumulator.pop()!
-            const right = accumulator.pop()!
-            const value = reducer.parallelCase(context, left, right)
-            accumulator.push(value)
-            break
-          }
-        }
-        break
-      }
-      case "Right": {
-        accumulator.push(either.right)
-        break
-      }
-    }
-  }
-  if (accumulator.length === 0) {
-    throw new Error(
-      "BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues"
-    )
-  }
-  return accumulator.pop()!
-})
-
-// -----------------------------------------------------------------------------
-// Pretty Printing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const pretty = <E>(cause: Cause.Cause<E>, options?: {
-  readonly renderErrorCause?: boolean | undefined
-}): string => {
-  if (isInterruptedOnly(cause)) {
-    return "All fibers interrupted without errors."
-  }
-  return prettyErrors<E>(cause).map(function(e) {
-    if (options?.renderErrorCause !== true || e.cause === undefined) {
-      return e.stack
-    }
-    return `${e.stack} {\n${renderErrorCause(e.cause as PrettyError, "  ")}\n}`
-  }).join("\n")
-}
-
-const renderErrorCause = (cause: PrettyError, prefix: string) => {
-  const lines = cause.stack!.split("\n")
-  let stack = `${prefix}[cause]: ${lines[0]}`
-  for (let i = 1, len = lines.length; i < len; i++) {
-    stack += `\n${prefix}${lines[i]}`
-  }
-  if (cause.cause) {
-    stack += ` {\n${renderErrorCause(cause.cause as PrettyError, `${prefix}  `)}\n${prefix}}`
-  }
-  return stack
-}
-
-/** @internal */
-export class PrettyError extends globalThis.Error implements Cause.PrettyError {
-  span: undefined | Span = undefined
-  constructor(originalError: unknown) {
-    const originalErrorIsObject = typeof originalError === "object" && originalError !== null
-    const prevLimit = Error.stackTraceLimit
-    Error.stackTraceLimit = 1
-    super(
-      prettyErrorMessage(originalError),
-      originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
-        ? { cause: new PrettyError(originalError.cause) }
-        : undefined
-    )
-    if (this.message === "") {
-      this.message = "An error has occurred"
-    }
-    Error.stackTraceLimit = prevLimit
-    this.name = originalError instanceof Error ? originalError.name : "Error"
-    if (originalErrorIsObject) {
-      if (spanSymbol in originalError) {
-        this.span = originalError[spanSymbol] as Span
-      }
-      Object.keys(originalError).forEach((key) => {
-        if (!(key in this)) {
-          // @ts-expect-error
-          this[key] = originalError[key]
-        }
-      })
-    }
-    this.stack = prettyErrorStack(
-      `${this.name}: ${this.message}`,
-      originalError instanceof Error && originalError.stack
-        ? originalError.stack
-        : "",
-      this.span
-    )
-  }
-}
-
-/**
- * A utility function for generating human-readable error messages from a generic error of type `unknown`.
- *
- * Rules:
- *
- * 1) If the input `u` is already a string, it's considered a message.
- * 2) If `u` is an Error instance with a message defined, it uses the message.
- * 3) If `u` has a user-defined `toString()` method, it uses that method.
- * 4) Otherwise, it uses `Inspectable.stringifyCircular` to produce a string representation and uses it as the error message,
- *   with "Error" added as a prefix.
- *
- * @internal
- */
-export const prettyErrorMessage = (u: unknown): string => {
-  // 1)
-  if (typeof u === "string") {
-    return u
-  }
-  // 2)
-  if (typeof u === "object" && u !== null && u instanceof Error) {
-    return u.message
-  }
-  // 3)
-  try {
-    if (
-      hasProperty(u, "toString") &&
-      isFunction(u["toString"]) &&
-      u["toString"] !== Object.prototype.toString &&
-      u["toString"] !== globalThis.Array.prototype.toString
-    ) {
-      return u["toString"]()
-    }
-  } catch {
-    // something's off, rollback to json
-  }
-  // 4)
-  return stringifyCircular(u)
-}
-
-const locationRegex = /\((.*)\)/g
-
-/** @internal */
-export const spanToTrace = globalValue("effect/Tracer/spanToTrace", () => new WeakMap())
-
-const prettyErrorStack = (message: string, stack: string, span?: Span | undefined): string => {
-  const out: Array<string> = [message]
-  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n")
-
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
-      i++
-      continue
-    }
-    if (lines[i].includes("Generator.next")) {
-      break
-    }
-    if (lines[i].includes("effect_internal_function")) {
-      break
-    }
-    out.push(
-      lines[i]
-        .replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1")
-        .replace(/EffectPrimitive\.\w+/, "<anonymous>")
-    )
-  }
-
-  if (span) {
-    let current: Span | AnySpan | undefined = span
-    let i = 0
-    while (current && current._tag === "Span" && i < 10) {
-      const stackFn = spanToTrace.get(current)
-      if (typeof stackFn === "function") {
-        const stack = stackFn()
-        if (typeof stack === "string") {
-          const locationMatchAll = stack.matchAll(locationRegex)
-          let match = false
-          for (const [, location] of locationMatchAll) {
-            match = true
-            out.push(`    at ${current.name} (${location})`)
-          }
-          if (!match) {
-            out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`)
-          }
-        } else {
-          out.push(`    at ${current.name}`)
-        }
-      } else {
-        out.push(`    at ${current.name}`)
-      }
-      current = Option.getOrUndefined(current.parent)
-      i++
-    }
-  }
-
-  return out.join("\n")
-}
-
-/** @internal */
-export const spanSymbol = Symbol.for("effect/SpanAnnotation")
-
-/** @internal */
-export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<PrettyError> =>
-  reduceWithContext(cause, void 0, {
-    emptyCase: (): Array<PrettyError> => [],
-    dieCase: (_, unknownError) => {
-      return [new PrettyError(unknownError)]
-    },
-    failCase: (_, error) => {
-      return [new PrettyError(error)]
-    },
-    interruptCase: () => [],
-    parallelCase: (_, l, r) => [...l, ...r],
-    sequentialCase: (_, l, r) => [...l, ...r]
-  })