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

package/src/internal/supervisor.ts

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

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

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

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