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

package/src/ChannelChildExecutorDecision.ts

@@ -0,0 +1,138 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/channel/childExecutorDecision"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ChildExecutorDecisionTypeId: unique symbol = internal.ChildExecutorDecisionTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ChildExecutorDecisionTypeId = typeof ChildExecutorDecisionTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type ChildExecutorDecision = Continue | Close | Yield
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace ChildExecutorDecision {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId
+  }
+}
+
+/**
+ * Continue executing the current substream
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Continue extends ChildExecutorDecision.Proto {
+  readonly _tag: "Continue"
+}
+
+/**
+ * Close the current substream with a given value and pass execution to the
+ * next substream
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Close extends ChildExecutorDecision.Proto {
+  readonly _tag: "Close"
+  readonly value: unknown
+}
+
+/**
+ * Pass execution to the next substream. This either pulls a new element
+ * from upstream, or yields to an already created active substream.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Yield extends ChildExecutorDecision.Proto {
+  readonly _tag: "Yield"
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Continue: (_: void) => ChildExecutorDecision = internal.Continue
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Close: (value: unknown) => ChildExecutorDecision = internal.Close
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Yield: (_: void) => ChildExecutorDecision = internal.Yield
+
+/**
+ * Returns `true` if the specified value is a `ChildExecutorDecision`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isChildExecutorDecision: (u: unknown) => u is ChildExecutorDecision = internal.isChildExecutorDecision
+
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Continue`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isContinue: (self: ChildExecutorDecision) => self is Continue = internal.isContinue
+
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Close`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isClose: (self: ChildExecutorDecision) => self is Close = internal.isClose
+
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Yield`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isYield: (self: ChildExecutorDecision) => self is Yield = internal.isYield
+
+/**
+ * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <A>(
+    options: { readonly onContinue: () => A; readonly onClose: (value: unknown) => A; readonly onYield: () => A }
+  ): (self: ChildExecutorDecision) => A
+  <A>(
+    self: ChildExecutorDecision,
+    options: { readonly onContinue: () => A; readonly onClose: (value: unknown) => A; readonly onYield: () => A }
+  ): A
+} = internal.match

package/src/ChannelMergeDecision.ts

@@ -0,0 +1,94 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import type * as Exit from "./Exit"
+import * as internal from "./internal/channel/mergeDecision"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MergeDecisionTypeId: unique symbol = internal.MergeDecisionTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MergeDecisionTypeId = typeof MergeDecisionTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MergeDecision<R, E0, Z0, E, Z> extends MergeDecision.Variance<R, E0, Z0, E, Z> {}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace MergeDecision {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<R, E0, Z0, E, Z> {
+    readonly [MergeDecisionTypeId]: {
+      _R: (_: never) => R
+      _E0: (_: E0) => void
+      _Z0: (_: Z0) => void
+      _E: (_: never) => E
+      _Z: (_: never) => Z
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Done: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => MergeDecision<R, unknown, unknown, E, Z> = internal.Done
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Await: <R, E0, Z0, E, Z>(
+  f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>
+) => MergeDecision<R, E0, Z0, E, Z> = internal.Await
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const AwaitConst: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => MergeDecision<R, unknown, unknown, E, Z> =
+  internal.AwaitConst
+
+/**
+ * Returns `true` if the specified value is a `MergeDecision`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isMergeDecision: (u: unknown) => u is MergeDecision<unknown, unknown, unknown, unknown, unknown> =
+  internal.isMergeDecision
+
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <R, E0, Z0, E, Z, Z2>(
+    options: {
+      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+    }
+  ): (self: MergeDecision<R, E0, Z0, E, Z>) => Z2
+  <R, E0, Z0, E, Z, Z2>(
+    self: MergeDecision<R, E0, Z0, E, Z>,
+    options: {
+      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+    }
+  ): Z2
+} = internal.match

package/src/ChannelMergeState.ts

@@ -0,0 +1,166 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import type * as Either from "./Either"
+import type * as Exit from "./Exit"
+import type * as Fiber from "./Fiber"
+import * as internal from "./internal/channel/mergeState"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MergeStateTypeId: unique symbol = internal.MergeStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MergeStateTypeId = typeof MergeStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> =
+  | BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+  | LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+  | RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace MergeState {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [MergeStateTypeId]: MergeStateTypeId
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface BothRunning<_Env, Err, Err1, _Err2, Elem, Done, Done1, _Done2> extends MergeState.Proto {
+  readonly _tag: "BothRunning"
+  readonly left: Fiber.Fiber<Err, Either.Either<Done, Elem>>
+  readonly right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface LeftDone<Env, _Err, Err1, Err2, _Elem, _Done, Done1, Done2> extends MergeState.Proto {
+  readonly _tag: "LeftDone"
+  readonly f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface RightDone<Env, Err, _Err1, Err2, _Elem, Done, _Done1, Done2> extends MergeState.Proto {
+  readonly _tag: "RightDone"
+  readonly f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const BothRunning: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.BothRunning
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const LeftDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.LeftDone
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const RightDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.RightDone
+
+/**
+ * Returns `true` if the specified value is a `MergeState`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isMergeState: (
+  u: unknown
+) => u is MergeState<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> = internal.isMergeState
+
+/**
+ * Returns `true` if the specified `MergeState` is a `BothRunning`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isBothRunning: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+) => self is BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.isBothRunning
+
+/**
+ * Returns `true` if the specified `MergeState` is a `LeftDone`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isLeftDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+) => self is LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.isLeftDone
+
+/**
+ * Returns `true` if the specified `MergeState` is a `RightDone`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isRightDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
+  self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>
+) => self is RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.isRightDone
+
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
+    options: {
+      readonly onBothRunning: (
+        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+    }
+  ): (self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>) => Z
+  <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
+    self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
+    options: {
+      readonly onBothRunning: (
+        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
+        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+      ) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+    }
+  ): Z
+} = internal.match

package/src/ChannelMergeStrategy.ts

@@ -0,0 +1,107 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/channel/mergeStrategy"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MergeStrategyTypeId: unique symbol = internal.MergeStrategyTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MergeStrategyTypeId = typeof MergeStrategyTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type MergeStrategy = BackPressure | BufferSliding
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace MergeStrategy {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [MergeStrategyTypeId]: MergeStrategyTypeId
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface BackPressure extends MergeStrategy.Proto {
+  readonly _tag: "BackPressure"
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface BufferSliding extends MergeStrategy.Proto {
+  readonly _tag: "BufferSliding"
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const BackPressure: (_: void) => MergeStrategy = internal.BackPressure
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const BufferSliding: (_: void) => MergeStrategy = internal.BufferSliding
+
+/**
+ * Returns `true` if the specified value is a `MergeStrategy`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isMergeStrategy: (u: unknown) => u is MergeStrategy = internal.isMergeStrategy
+
+/**
+ * Returns `true` if the specified `MergeStrategy` is a `BackPressure`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isBackPressure: (self: MergeStrategy) => self is BackPressure = internal.isBackPressure
+
+/**
+ * Returns `true` if the specified `MergeStrategy` is a `BufferSliding`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isBufferSliding: (self: MergeStrategy) => self is BufferSliding = internal.isBufferSliding
+
+/**
+ * Folds an `MergeStrategy` into a value of type `A`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <A>(options: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }): (self: MergeStrategy) => A
+  <A>(self: MergeStrategy, options: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }): A
+} = internal.match

package/src/ChannelSingleProducerAsyncInput.ts

@@ -0,0 +1,68 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Cause from "./Cause"
+import type * as Effect from "./Effect"
+import type * as Either from "./Either"
+import type * as Exit from "./Exit"
+import * as internal from "./internal/channel/singleProducerAsyncInput"
+
+/**
+ * An MVar-like abstraction for sending data to channels asynchronously which is
+ * designed for one producer and multiple consumers.
+ *
+ * Features the following semantics:
+ *   - Buffer of size 1.
+ *   - When emitting, the producer waits for a consumer to pick up the value to
+ *     prevent "reading ahead" too much.
+ *   - Once an emitted element is read by a consumer, it is cleared from the
+ *     buffer, so that at most one consumer sees every emitted element.
+ *   - When sending a done or error signal, the producer does not wait for a
+ *     consumer to pick up the signal. The signal stays in the buffer after
+ *     being read by a consumer, so it can be propagated to multiple consumers.
+ *   - Trying to publish another emit/error/done after an error/done have
+ *     already been published results in an interruption.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface SingleProducerAsyncInput<Err, Elem, Done>
+  extends AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done>
+{
+  close(): Effect.Effect<never, never, unknown>
+  take(): Effect.Effect<never, never, Exit.Exit<Either.Either<Err, Done>, Elem>>
+}
+
+/**
+ * Producer-side view of `SingleProducerAsyncInput` for variance purposes.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface AsyncInputProducer<Err, Elem, Done> {
+  awaitRead(): Effect.Effect<never, never, unknown>
+  done(value: Done): Effect.Effect<never, never, unknown>
+  emit(element: Elem): Effect.Effect<never, never, unknown>
+  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown>
+}
+
+/**
+ * Consumer-side view of `SingleProducerAsyncInput` for variance purposes.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface AsyncInputConsumer<Err, Elem, Done> {
+  takeWith<A>(
+    onError: (cause: Cause.Cause<Err>) => A,
+    onElement: (element: Elem) => A,
+    onDone: (value: Done) => A
+  ): Effect.Effect<never, never, A>
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Err, Elem, Done>() => Effect.Effect<never, never, SingleProducerAsyncInput<Err, Elem, Done>> =
+  internal.make

package/src/ChannelUpstreamPullRequest.ts

@@ -0,0 +1,110 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/channel/upstreamPullRequest"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const UpstreamPullRequestTypeId: unique symbol = internal.UpstreamPullRequestTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type UpstreamPullRequestTypeId = typeof UpstreamPullRequestTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type UpstreamPullRequest<A> = Pulled<A> | NoUpstream
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace UpstreamPullRequest {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<A> {
+    readonly [UpstreamPullRequestTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Pulled<A> extends UpstreamPullRequest.Variance<A> {
+  readonly _tag: "Pulled"
+  readonly value: A
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface NoUpstream extends UpstreamPullRequest.Variance<never> {
+  readonly _tag: "NoUpstream"
+  readonly activeDownstreamCount: number
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Pulled: <A>(value: A) => UpstreamPullRequest<A> = internal.Pulled
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const NoUpstream: (activeDownstreamCount: number) => UpstreamPullRequest<never> = internal.NoUpstream
+
+/**
+ * Returns `true` if the specified value is an `UpstreamPullRequest`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isUpstreamPullRequest: (u: unknown) => u is UpstreamPullRequest<unknown> = internal.isUpstreamPullRequest
+
+/**
+ * Returns `true` if the specified `UpstreamPullRequest` is a `Pulled`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isPulled: <A>(self: UpstreamPullRequest<A>) => self is Pulled<A> = internal.isPulled
+
+/**
+ * Returns `true` if the specified `UpstreamPullRequest` is a `NoUpstream`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isNoUpstream: <A>(self: UpstreamPullRequest<A>) => self is NoUpstream = internal.isNoUpstream
+
+/**
+ * Folds an `UpstreamPullRequest<A>` into a value of type `Z`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <A, Z>(
+    options: { readonly onPulled: (value: A) => Z; readonly onNoUpstream: (activeDownstreamCount: number) => Z }
+  ): (self: UpstreamPullRequest<A>) => Z
+  <A, Z>(
+    self: UpstreamPullRequest<A>,
+    options: { readonly onPulled: (value: A) => Z; readonly onNoUpstream: (activeDownstreamCount: number) => Z }
+  ): Z
+} = internal.match