effect 2.0.0-next.44 → 2.0.0-next.46

package/src/internal/supervisor.ts

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

package/src/internal/synchronizedRef.ts

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

package/src/internal/testing/sleep.ts

@@ -0,0 +1,27 @@
+import type * as Deferred from "../../Deferred"
+import type * as Duration from "../../Duration"
+import type * as FiberId from "../../FiberId"
+
+/**
+ * `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<never, void>
+  readonly fiberId: FiberId.FiberId
+}
+
+/** @internal */
+export const make = (
+  duration: Duration.Duration,
+  deferred: Deferred.Deferred<never, void>,
+  fiberId: FiberId.FiberId
+): Sleep => ({
+  duration,
+  deferred,
+  fiberId
+})