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

package/src/internal/supervisor.ts

@@ -0,0 +1,303 @@
+import type * as Context from "../Context.js"
+import type * as Effect from "../Effect.js"
+import type * as Exit from "../Exit.js"
+import type * as Fiber from "../Fiber.js"
+import { pipe } from "../Function.js"
+import { globalValue } from "../GlobalValue.js"
+import * as MutableRef from "../MutableRef.js"
+import type * as Option from "../Option.js"
+import { hasProperty, isTagged } from "../Predicate.js"
+import * as SortedSet from "../SortedSet.js"
+import type * as Supervisor from "../Supervisor.js"
+import * as core from "./core.js"
+
+/** @internal */
+const SupervisorSymbolKey = "effect/Supervisor"
+
+/** @internal */
+export const SupervisorTypeId: Supervisor.SupervisorTypeId = Symbol.for(
+  SupervisorSymbolKey
+) as Supervisor.SupervisorTypeId
+
+/** @internal */
+export const supervisorVariance = {
+  /* c8 ignore next */
+  _T: (_: never) => _
+}
+
+/** @internal */
+export class ProxySupervisor<out T> implements Supervisor.Supervisor<T> {
+  readonly [SupervisorTypeId] = supervisorVariance
+
+  constructor(
+    readonly underlying: Supervisor.Supervisor<any>,
+    readonly value0: Effect.Effect<T>
+  ) {
+  }
+
+  get value(): Effect.Effect<T> {
+    return this.value0
+  }
+
+  onStart<A, E, R>(
+    context: Context.Context<R>,
+    effect: Effect.Effect<A, E, R>,
+    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    fiber: Fiber.RuntimeFiber<A, E>
+  ): void {
+    this.underlying.onStart(context, effect, parent, fiber)
+  }
+
+  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.underlying.onEnd(value, fiber)
+  }
+
+  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void {
+    this.underlying.onEffect(fiber, effect)
+  }
+
+  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.underlying.onSuspend(fiber)
+  }
+
+  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.underlying.onResume(fiber)
+  }
+
+  map<B>(f: (a: T) => B): Supervisor.Supervisor<B> {
+    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
+  }
+
+  zip<B>(right: Supervisor.Supervisor<B>): Supervisor.Supervisor<[T, B]> {
+    return new Zip(this, right)
+  }
+}
+
+/** @internal */
+export class Zip<out T0, out T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
+  readonly _tag = "Zip"
+  readonly [SupervisorTypeId] = supervisorVariance
+
+  constructor(
+    readonly left: Supervisor.Supervisor<T0>,
+    readonly right: Supervisor.Supervisor<T1>
+  ) {
+  }
+
+  get value(): Effect.Effect<[T0, T1]> {
+    return core.zip(this.left.value, this.right.value)
+  }
+
+  onStart<A, E, R>(
+    context: Context.Context<R>,
+    effect: Effect.Effect<A, E, R>,
+    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    fiber: Fiber.RuntimeFiber<A, E>
+  ): void {
+    this.left.onStart(context, effect, parent, fiber)
+    this.right.onStart(context, effect, parent, fiber)
+  }
+
+  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.left.onEnd(value, fiber)
+    this.right.onEnd(value, fiber)
+  }
+
+  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void {
+    this.left.onEffect(fiber, effect)
+    this.right.onEffect(fiber, effect)
+  }
+
+  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.left.onSuspend(fiber)
+    this.right.onSuspend(fiber)
+  }
+
+  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.left.onResume(fiber)
+    this.right.onResume(fiber)
+  }
+
+  map<B>(f: (a: [T0, T1]) => B): Supervisor.Supervisor<B> {
+    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
+  }
+
+  zip<A>(right: Supervisor.Supervisor<A>): Supervisor.Supervisor<[[T0, T1], A]> {
+    return new Zip(this, right)
+  }
+}
+
+/** @internal */
+export const isZip = (self: unknown): self is Zip<any, any> =>
+  hasProperty(self, SupervisorTypeId) && isTagged(self, "Zip")
+
+/** @internal */
+export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>> {
+  readonly [SupervisorTypeId] = supervisorVariance
+
+  readonly fibers: Set<Fiber.RuntimeFiber<any, any>> = new Set()
+
+  get value(): Effect.Effect<Array<Fiber.RuntimeFiber<any, any>>> {
+    return core.sync(() => Array.from(this.fibers))
+  }
+
+  onStart<A, E, R>(
+    _context: Context.Context<R>,
+    _effect: Effect.Effect<A, E, R>,
+    _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    fiber: Fiber.RuntimeFiber<A, E>
+  ): void {
+    this.fibers.add(fiber)
+  }
+
+  onEnd<A, E>(_value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
+    this.fibers.delete(fiber)
+  }
+
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
+    //
+  }
+
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  map<B>(f: (a: Array<Fiber.RuntimeFiber<any, any>>) => B): Supervisor.Supervisor<B> {
+    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
+  }
+
+  zip<A>(
+    right: Supervisor.Supervisor<A>
+  ): Supervisor.Supervisor<[Array<Fiber.RuntimeFiber<any, any>>, A]> {
+    return new Zip(this, right)
+  }
+
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
+    return execution()
+  }
+}
+
+/** @internal */
+export class Const<out T> implements Supervisor.Supervisor<T> {
+  readonly [SupervisorTypeId] = supervisorVariance
+
+  constructor(readonly effect: Effect.Effect<T>) {
+  }
+
+  get value(): Effect.Effect<T> {
+    return this.effect
+  }
+
+  onStart<A, E, R>(
+    _context: Context.Context<R>,
+    _effect: Effect.Effect<A, E, R>,
+    _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    _fiber: Fiber.RuntimeFiber<A, E>
+  ): void {
+    //
+  }
+
+  onEnd<A, E>(_value: Exit.Exit<A, E>, _fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
+    //
+  }
+
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  map<B>(f: (a: T) => B): Supervisor.Supervisor<B> {
+    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
+  }
+
+  zip<A>(right: Supervisor.Supervisor<A>): Supervisor.Supervisor<[T, A]> {
+    return new Zip(this, right)
+  }
+
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
+    return execution()
+  }
+}
+
+class FibersIn implements Supervisor.Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>> {
+  readonly [SupervisorTypeId] = supervisorVariance
+
+  constructor(readonly ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>) {
+  }
+
+  get value(): Effect.Effect<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>> {
+    return core.sync(() => MutableRef.get(this.ref))
+  }
+
+  onStart<A, E, R>(
+    _context: Context.Context<R>,
+    _effect: Effect.Effect<A, E, R>,
+    _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+    fiber: Fiber.RuntimeFiber<A, E>
+  ): void {
+    pipe(this.ref, MutableRef.set(pipe(MutableRef.get(this.ref), SortedSet.add(fiber))))
+  }
+
+  onEnd<A, E>(_value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
+    pipe(this.ref, MutableRef.set(pipe(MutableRef.get(this.ref), SortedSet.remove(fiber))))
+  }
+
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
+    //
+  }
+
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
+    //
+  }
+
+  map<B>(f: (a: SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>) => B): Supervisor.Supervisor<B> {
+    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
+  }
+
+  zip<A>(
+    right: Supervisor.Supervisor<A>
+  ): Supervisor.Supervisor<[SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>, A]> {
+    return new Zip(this, right)
+  }
+
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
+    return execution()
+  }
+}
+
+/** @internal */
+export const unsafeTrack = (): Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>> => {
+  return new Track()
+}
+
+/** @internal */
+export const track: Effect.Effect<Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>>> = core.sync(unsafeTrack)
+
+/** @internal */
+export const fromEffect = <A>(effect: Effect.Effect<A>): Supervisor.Supervisor<A> => {
+  return new Const(effect)
+}
+
+/** @internal */
+export const none = globalValue("effect/Supervisor/none", () => fromEffect(core.void))
+
+/** @internal */
+export const fibersIn = (
+  ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
+): Effect.Effect<Supervisor.Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>> =>
+  core.sync(() => new FibersIn(ref))

package/src/internal/synchronizedRef.ts

@@ -0,0 +1,114 @@
+import type * as Effect from "../Effect.js"
+import { dual, pipe } from "../Function.js"
+import * as Option from "../Option.js"
+import type * as Synchronized from "../SynchronizedRef.js"
+import * as core from "./core.js"
+
+/** @internal */
+export const getAndUpdateEffect = dual<
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+>(2, (self, f) =>
+  self.modifyEffect(
+    (value) => core.map(f(value), (result) => [value, result] as const)
+  ))
+
+/** @internal */
+export const getAndUpdateSomeEffect = dual<
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
+  <A, R, E>(
+    self: Synchronized.SynchronizedRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => Effect.Effect<A, E, R>
+>(2, (self, pf) =>
+  self.modifyEffect((value) => {
+    const result = pf(value)
+    switch (result._tag) {
+      case "None": {
+        return core.succeed([value, value] as const)
+      }
+      case "Some": {
+        return core.map(result.value, (newValue) => [value, newValue] as const)
+      }
+    }
+  }))
+
+/** @internal */
+export const modify = dual<
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B>,
+  <A, B>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<B>
+>(2, (self, f) => self.modify(f))
+
+/** @internal */
+export const modifyEffect = dual<
+  <A, B, E, R>(
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>,
+  <A, B, E, R>(
+    self: Synchronized.SynchronizedRef<A>,
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => Effect.Effect<B, E, R>
+>(2, (self, f) => self.modifyEffect(f))
+
+/** @internal */
+export const modifySomeEffect = dual<
+  <A, B, R, E>(
+    fallback: B,
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>,
+  <A, B, R, E>(
+    self: Synchronized.SynchronizedRef<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ) => Effect.Effect<B, E, R>
+>(3, (self, fallback, pf) =>
+  self.modifyEffect(
+    (value) => pipe(pf(value), Option.getOrElse(() => core.succeed([fallback, value] as const)))
+  ))
+
+/** @internal */
+export const updateEffect = dual<
+  <A, R, E>(
+    f: (a: A) => Effect.Effect<A, E, R>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+>(2, (self, f) =>
+  self.modifyEffect((value) =>
+    core.map(
+      f(value),
+      (result) => [undefined as void, result] as const
+    )
+  ))
+
+/** @internal */
+export const updateAndGetEffect = dual<
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+>(2, (self, f) =>
+  self.modifyEffect(
+    (value) => core.map(f(value), (result) => [result, result] as const)
+  ))
+
+/** @internal */
+export const updateSomeEffect = dual<
+  <A, R, E>(
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>,
+  <A, R, E>(
+    self: Synchronized.SynchronizedRef<A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => Effect.Effect<void, E, R>
+>(2, (self, pf) =>
+  self.modifyEffect((value) => {
+    const result = pf(value)
+    switch (result._tag) {
+      case "None": {
+        return core.succeed([void 0, value] as const)
+      }
+      case "Some": {
+        return core.map(result.value, (a) => [void 0, a] as const)
+      }
+    }
+  }))

package/src/internal/take.ts

@@ -0,0 +1,199 @@
+import * as Cause from "../Cause.js"
+import * as Chunk from "../Chunk.js"
+import * as Effect from "../Effect.js"
+import * as Exit from "../Exit.js"
+import { constFalse, constTrue, dual, pipe } from "../Function.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import type * as Take from "../Take.js"
+
+/** @internal */
+const TakeSymbolKey = "effect/Take"
+
+/** @internal */
+export const TakeTypeId: Take.TakeTypeId = Symbol.for(
+  TakeSymbolKey
+) as Take.TakeTypeId
+
+const takeVariance = {
+  /* c8 ignore next */
+  _A: (_: never) => _,
+  /* c8 ignore next */
+  _E: (_: never) => _
+}
+
+/** @internal */
+export class TakeImpl<out A, out E = never> implements Take.Take<A, E> {
+  readonly [TakeTypeId] = takeVariance
+  constructor(readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) {
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const chunk = <A>(chunk: Chunk.Chunk<A>): Take.Take<A> => new TakeImpl(Exit.succeed(chunk))
+
+/** @internal */
+export const die = (defect: unknown): Take.Take<never> => new TakeImpl(Exit.die(defect))
+
+/** @internal */
+export const dieMessage = (message: string): Take.Take<never> =>
+  new TakeImpl(Exit.die(new Cause.RuntimeException(message)))
+
+/** @internal */
+export const done = <A, E>(self: Take.Take<A, E>): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> =>
+  Effect.suspend(() => self.exit)
+
+/** @internal */
+export const end: Take.Take<never> = new TakeImpl(Exit.fail(Option.none()))
+
+/** @internal */
+export const fail = <E>(error: E): Take.Take<never, E> => new TakeImpl(Exit.fail(Option.some(error)))
+
+/** @internal */
+export const failCause = <E>(cause: Cause.Cause<E>): Take.Take<never, E> =>
+  new TakeImpl(Exit.failCause(pipe(cause, Cause.map(Option.some))))
+
+/** @internal */
+export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Take.Take<A, E>, never, R> =>
+  Effect.matchCause(effect, { onFailure: failCause, onSuccess: of })
+
+/** @internal */
+export const fromExit = <A, E>(exit: Exit.Exit<A, E>): Take.Take<A, E> =>
+  new TakeImpl(pipe(exit, Exit.mapBoth({ onFailure: Option.some, onSuccess: Chunk.of })))
+
+/** @internal */
+export const fromPull = <A, E, R>(
+  pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
+): Effect.Effect<Take.Take<A, E>, never, R> =>
+  Effect.matchCause(pull, {
+    onFailure: (cause) =>
+      Option.match(Cause.flipCauseOption(cause), {
+        onNone: () => end,
+        onSome: failCause
+      }),
+    onSuccess: chunk
+  })
+
+/** @internal */
+export const isDone = <A, E>(self: Take.Take<A, E>): boolean =>
+  Exit.match(self.exit, {
+    onFailure: (cause) => Option.isNone(Cause.flipCauseOption(cause)),
+    onSuccess: constFalse
+  })
+
+/** @internal */
+export const isFailure = <A, E>(self: Take.Take<A, E>): boolean =>
+  Exit.match(self.exit, {
+    onFailure: (cause) => Option.isSome(Cause.flipCauseOption(cause)),
+    onSuccess: constFalse
+  })
+
+/** @internal */
+export const isSuccess = <A, E>(self: Take.Take<A, E>): boolean =>
+  Exit.match(self.exit, {
+    onFailure: constFalse,
+    onSuccess: constTrue
+  })
+
+/** @internal */
+export const make = <A, E>(
+  exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
+): Take.Take<A, E> => new TakeImpl(exit)
+
+/** @internal */
+export const match = dual<
+  <Z, E, Z2, A, Z3>(
+    options: {
+      readonly onEnd: () => Z
+      readonly onFailure: (cause: Cause.Cause<E>) => Z2
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+    }
+  ) => (self: Take.Take<A, E>) => Z | Z2 | Z3,
+  <A, E, Z, Z2, Z3>(
+    self: Take.Take<A, E>,
+    options: {
+      readonly onEnd: () => Z
+      readonly onFailure: (cause: Cause.Cause<E>) => Z2
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+    }
+  ) => Z | Z2 | Z3
+>(2, <A, E, Z, Z2, Z3>(
+  self: Take.Take<A, E>,
+  { onEnd, onFailure, onSuccess }: {
+    readonly onEnd: () => Z
+    readonly onFailure: (cause: Cause.Cause<E>) => Z2
+    readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+  }
+): Z | Z2 | Z3 =>
+  Exit.match(self.exit, {
+    onFailure: (cause) =>
+      Option.match(Cause.flipCauseOption(cause), {
+        onNone: onEnd,
+        onSome: onFailure
+      }),
+    onSuccess
+  }))
+
+/** @internal */
+export const matchEffect = dual<
+  <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
+    options: {
+      readonly onEnd: Effect.Effect<Z, E2, R>
+      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
+    }
+  ) => (self: Take.Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>,
+  <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+    self: Take.Take<A, E>,
+    options: {
+      readonly onEnd: Effect.Effect<Z, E2, R>
+      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
+    }
+  ) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
+>(2, <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+  self: Take.Take<A, E>,
+  { onEnd, onFailure, onSuccess }: {
+    readonly onEnd: Effect.Effect<Z, E2, R>
+    readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
+    readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
+  }
+): Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3> =>
+  Exit.matchEffect(self.exit, {
+    onFailure: (cause) =>
+      Option.match<Cause.Cause<E>, Effect.Effect<Z | Z2, E2 | E, R | R2>>(Cause.flipCauseOption(cause), {
+        onNone: () => onEnd,
+        onSome: onFailure
+      }),
+    onSuccess
+  }))
+
+/** @internal */
+export const map = dual<
+  <A, B>(f: (a: A) => B) => <E>(self: Take.Take<A, E>) => Take.Take<B, E>,
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B) => Take.Take<B, E>
+>(
+  2,
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B): Take.Take<B, E> =>
+    new TakeImpl(pipe(self.exit, Exit.map(Chunk.map(f))))
+)
+
+/** @internal */
+export const of = <A>(value: A): Take.Take<A> => new TakeImpl(Exit.succeed(Chunk.of(value)))
+
+/** @internal */
+export const tap = dual<
+  <A, X, E2, R>(
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
+  ) => <E>(self: Take.Take<A, E>) => Effect.Effect<void, E2 | E, R>,
+  <A, E, X, E2, R>(
+    self: Take.Take<A, E>,
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
+  ) => Effect.Effect<void, E2 | E, R>
+>(2, <A, E, X, E2, R>(
+  self: Take.Take<A, E>,
+  f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
+): Effect.Effect<void, E2 | E, R> => pipe(self.exit, Exit.forEachEffect(f), Effect.asVoid))

package/src/internal/testing/sleep.ts

@@ -0,0 +1,27 @@
+import type * as Deferred from "../../Deferred.js"
+import type * as Duration from "../../Duration.js"
+import type * as FiberId from "../../FiberId.js"
+
+/**
+ * `Sleep` represents the state of a scheduled effect, including the time the
+ * effect is scheduled to run, a promise that can be completed to resume
+ * execution of the effect, and the fiber executing the effect.
+ *
+ * @internal
+ */
+export interface Sleep {
+  readonly duration: Duration.Duration
+  readonly deferred: Deferred.Deferred<void>
+  readonly fiberId: FiberId.FiberId
+}
+
+/** @internal */
+export const make = (
+  duration: Duration.Duration,
+  deferred: Deferred.Deferred<void>,
+  fiberId: FiberId.FiberId
+): Sleep => ({
+  duration,
+  deferred,
+  fiberId
+})