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

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -0,0 +1,261 @@
+import * as Cause from "../../Cause"
+import type * as SingleProducerAsyncInput from "../../ChannelSingleProducerAsyncInput"
+import * as Deferred from "../../Deferred"
+import * as Effect from "../../Effect"
+import * as Either from "../../Either"
+import * as Exit from "../../Exit"
+import { pipe } from "../../Function"
+import * as Ref from "../../Ref"
+
+/** @internal */
+type State<Err, Elem, _Done> =
+  | Empty
+  | Emit<Err, Elem, _Done>
+  | Error<Err>
+  | Done<_Done>
+
+/** @internal */
+const OP_STATE_EMPTY = "Empty" as const
+
+/** @internal */
+type OP_STATE_EMPTY = typeof OP_STATE_EMPTY
+
+/** @internal */
+const OP_STATE_EMIT = "Emit" as const
+
+/** @internal */
+type OP_STATE_EMIT = typeof OP_STATE_EMIT
+
+/** @internal */
+const OP_STATE_ERROR = "Error" as const
+
+/** @internal */
+type OP_STATE_ERROR = typeof OP_STATE_ERROR
+
+/** @internal */
+const OP_STATE_DONE = "Done" as const
+
+/** @internal */
+type OP_STATE_DONE = typeof OP_STATE_DONE
+
+/** @internal */
+interface Empty {
+  readonly _tag: OP_STATE_EMPTY
+  readonly notifyProducer: Deferred.Deferred<never, void>
+}
+
+/** @internal */
+interface Emit<Err, Elem, Done> {
+  readonly _tag: OP_STATE_EMIT
+  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Err, Either.Either<Done, Elem>>>
+}
+
+/** @internal */
+interface Error<Err> {
+  readonly _tag: OP_STATE_ERROR
+  readonly cause: Cause.Cause<Err>
+}
+
+/** @internal */
+interface Done<_Done> {
+  readonly _tag: OP_STATE_DONE
+  readonly done: _Done
+}
+
+/** @internal */
+const stateEmpty = (notifyProducer: Deferred.Deferred<never, void>): State<never, never, never> => ({
+  _tag: OP_STATE_EMPTY,
+  notifyProducer
+})
+
+/** @internal */
+const stateEmit = <Err, Elem, Done>(
+  notifyConsumers: ReadonlyArray<Deferred.Deferred<Err, Either.Either<Done, Elem>>>
+): State<Err, Elem, Done> => ({
+  _tag: OP_STATE_EMIT,
+  notifyConsumers
+})
+
+/** @internal */
+const stateError = <Err>(cause: Cause.Cause<Err>): State<Err, never, never> => ({
+  _tag: OP_STATE_ERROR,
+  cause
+})
+
+/** @internal */
+const stateDone = <Done>(done: Done): State<never, never, Done> => ({
+  _tag: OP_STATE_DONE,
+  done
+})
+
+/** @internal */
+class SingleProducerAsyncInputImpl<Err, Elem, Done>
+  implements SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
+{
+  constructor(readonly ref: Ref.Ref<State<Err, Elem, Done>>) {
+  }
+
+  awaitRead(): Effect.Effect<never, never, unknown> {
+    return Effect.flatten(
+      Ref.modify(this.ref, (state) =>
+        state._tag === OP_STATE_EMPTY ?
+          [Deferred.await(state.notifyProducer), state as State<Err, Elem, Done>] :
+          [Effect.unit, state])
+    )
+  }
+
+  close(): Effect.Effect<never, never, unknown> {
+    return Effect.fiberIdWith((fiberId) => this.error(Cause.interrupt(fiberId)))
+  }
+
+  done(value: Done): Effect.Effect<never, never, unknown> {
+    return Effect.flatten(
+      Ref.modify(this.ref, (state) => {
+        switch (state._tag) {
+          case OP_STATE_EMPTY: {
+            return [Deferred.await(state.notifyProducer), state]
+          }
+          case OP_STATE_EMIT: {
+            return [
+              Effect.forEach(
+                state.notifyConsumers,
+                (deferred) => Deferred.succeed(deferred, Either.left(value)),
+                { discard: true }
+              ),
+              stateDone(value) as State<Err, Elem, Done>
+            ]
+          }
+          case OP_STATE_ERROR: {
+            return [Effect.interrupt, state]
+          }
+          case OP_STATE_DONE: {
+            return [Effect.interrupt, state]
+          }
+        }
+      })
+    )
+  }
+
+  emit(element: Elem): Effect.Effect<never, never, unknown> {
+    return Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+      Effect.flatten(
+        Ref.modify(this.ref, (state) => {
+          switch (state._tag) {
+            case OP_STATE_EMPTY: {
+              return [Deferred.await(state.notifyProducer), state]
+            }
+            case OP_STATE_EMIT: {
+              const notifyConsumer = state.notifyConsumers[0]
+              const notifyConsumers = state.notifyConsumers.slice(1)
+              if (notifyConsumer !== undefined) {
+                return [
+                  Deferred.succeed(notifyConsumer, Either.right(element)),
+                  (notifyConsumers.length === 0 ?
+                    stateEmpty(deferred) :
+                    stateEmit(notifyConsumers)) as State<Err, Elem, Done>
+                ]
+              }
+              throw new Error(
+                "Bug: Channel.SingleProducerAsyncInput.emit - Queue was empty! Please report an issue at https://github.com/Effect-TS/stream/issues"
+              )
+            }
+            case OP_STATE_ERROR: {
+              return [Effect.interrupt, state]
+            }
+            case OP_STATE_DONE: {
+              return [Effect.interrupt, state]
+            }
+          }
+        })
+      ))
+  }
+
+  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown> {
+    return Effect.flatten(
+      Ref.modify(this.ref, (state) => {
+        switch (state._tag) {
+          case OP_STATE_EMPTY: {
+            return [Deferred.await(state.notifyProducer), state]
+          }
+          case OP_STATE_EMIT: {
+            return [
+              Effect.forEach(
+                state.notifyConsumers,
+                (deferred) => Deferred.failCause(deferred, cause),
+                { discard: true }
+              ),
+              stateError(cause) as State<Err, Elem, Done>
+            ]
+          }
+          case OP_STATE_ERROR: {
+            return [Effect.interrupt, state]
+          }
+          case OP_STATE_DONE: {
+            return [Effect.interrupt, state]
+          }
+        }
+      })
+    )
+  }
+
+  take(): Effect.Effect<never, never, Exit.Exit<Either.Either<Err, Done>, Elem>> {
+    return this.takeWith(
+      (cause) => Exit.failCause(Cause.map(cause, Either.left)),
+      (elem) => Exit.succeed(elem) as Exit.Exit<Either.Either<Err, Done>, Elem>,
+      (done) => Exit.fail(Either.right(done))
+    )
+  }
+
+  takeWith<A>(
+    onError: (cause: Cause.Cause<Err>) => A,
+    onElement: (element: Elem) => A,
+    onDone: (value: Done) => A
+  ): Effect.Effect<never, never, A> {
+    return Effect.flatMap(Deferred.make<Err, Either.Either<Done, Elem>>(), (deferred) =>
+      Effect.flatten(
+        Ref.modify(this.ref, (state) => {
+          switch (state._tag) {
+            case OP_STATE_EMPTY: {
+              return [
+                Effect.zipRight(
+                  Deferred.succeed(state.notifyProducer, void 0),
+                  Effect.matchCause(Deferred.await(deferred), {
+                    onFailure: onError,
+                    onSuccess: Either.match({ onLeft: onDone, onRight: onElement })
+                  })
+                ),
+                stateEmit([deferred])
+              ]
+            }
+            case OP_STATE_EMIT: {
+              return [
+                Effect.matchCause(Deferred.await(deferred), {
+                  onFailure: onError,
+                  onSuccess: Either.match({ onLeft: onDone, onRight: onElement })
+                }),
+                stateEmit([...state.notifyConsumers, deferred])
+              ]
+            }
+            case OP_STATE_ERROR: {
+              return [Effect.succeed(onError(state.cause)), state]
+            }
+            case OP_STATE_DONE: {
+              return [Effect.succeed(onDone(state.done)), state]
+            }
+          }
+        })
+      ))
+  }
+}
+
+/** @internal */
+export const make = <Err, Elem, Done>(): Effect.Effect<
+  never,
+  never,
+  SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
+> =>
+  pipe(
+    Deferred.make<never, void>(),
+    Effect.flatMap((deferred) => Ref.make(stateEmpty(deferred) as State<Err, Elem, Done>)),
+    Effect.map((ref) => new SingleProducerAsyncInputImpl(ref))
+  )

package/src/internal/channel/subexecutor.ts

@@ -0,0 +1,229 @@
+import type * as ChildExecutorDecision from "../../ChannelChildExecutorDecision"
+import type * as UpstreamPullRequest from "../../ChannelUpstreamPullRequest"
+import type * as UpstreamPullStrategy from "../../ChannelUpstreamPullStrategy"
+import * as Effect from "../../Effect"
+import * as Exit from "../../Exit"
+import { pipe } from "../../Function"
+import type { ErasedChannel, ErasedExecutor } from "./channelExecutor"
+
+/** @internal */
+export interface Subexecutor<R> {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined
+  enqueuePullFromChild(child: PullFromChild<R>): Subexecutor<R>
+}
+
+/** @internal */
+export type Primitive<Env> = PullFromChild<Env> | PullFromUpstream<Env> | DrainChildExecutors<Env> | Emit<Env>
+
+/** @internal */
+export const OP_PULL_FROM_CHILD = "PullFromChild" as const
+
+/** @internal */
+export type OP_PULL_FROM_CHILD = typeof OP_PULL_FROM_CHILD
+
+/** @internal */
+export const OP_PULL_FROM_UPSTREAM = "PullFromUpstream" as const
+
+/** @internal */
+export type OP_PULL_FROM_UPSTREAM = typeof OP_PULL_FROM_UPSTREAM
+
+/** @internal */
+export const OP_DRAIN_CHILD_EXECUTORS = "DrainChildExecutors" as const
+
+/** @internal */
+export type OP_DRAIN_CHILD_EXECUTORS = typeof OP_DRAIN_CHILD_EXECUTORS
+
+/** @internal */
+export const OP_EMIT = "Emit" as const
+
+/** @internal */
+export type OP_EMIT = typeof OP_EMIT
+
+/**
+ * Execute the `childExecutor` and on each emitted value, decide what to do by
+ * `onEmit`.
+ *
+ * @internal
+ */
+export class PullFromChild<R> implements Subexecutor<R> {
+  readonly _tag: OP_PULL_FROM_CHILD = OP_PULL_FROM_CHILD
+
+  constructor(
+    readonly childExecutor: ErasedExecutor<R>,
+    readonly parentSubexecutor: Subexecutor<R>,
+    readonly onEmit: (value: unknown) => ChildExecutorDecision.ChildExecutorDecision
+  ) {
+  }
+
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+    const fin1 = this.childExecutor.close(exit)
+    const fin2 = this.parentSubexecutor.close(exit)
+    if (fin1 !== undefined && fin2 !== undefined) {
+      return Effect.zipWith(
+        Effect.exit(fin1),
+        Effect.exit(fin2),
+        (exit1, exit2) => pipe(exit1, Exit.zipRight(exit2))
+      )
+    } else if (fin1 !== undefined) {
+      return fin1
+    } else if (fin2 !== undefined) {
+      return fin2
+    } else {
+      return undefined
+    }
+  }
+
+  enqueuePullFromChild(_child: PullFromChild<R>): Subexecutor<R> {
+    return this
+  }
+}
+
+/**
+ * Execute `upstreamExecutor` and for each emitted element, spawn a child
+ * channel and continue with processing it by `PullFromChild`.
+ *
+ * @internal
+ */
+export class PullFromUpstream<R> implements Subexecutor<R> {
+  readonly _tag: OP_PULL_FROM_UPSTREAM = OP_PULL_FROM_UPSTREAM
+
+  constructor(
+    readonly upstreamExecutor: ErasedExecutor<R>,
+    readonly createChild: (value: unknown) => ErasedChannel<R>,
+    readonly lastDone: unknown,
+    readonly activeChildExecutors: ReadonlyArray<PullFromChild<R> | undefined>,
+    readonly combineChildResults: (x: unknown, y: unknown) => unknown,
+    readonly combineWithChildResult: (x: unknown, y: unknown) => unknown,
+    readonly onPull: (
+      request: UpstreamPullRequest.UpstreamPullRequest<unknown>
+    ) => UpstreamPullStrategy.UpstreamPullStrategy<unknown>,
+    readonly onEmit: (value: unknown) => ChildExecutorDecision.ChildExecutorDecision
+  ) {
+  }
+
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+    const fin1 = this.upstreamExecutor.close(exit)
+    const fins = [
+      ...this.activeChildExecutors.map((child) =>
+        child !== undefined ?
+          child.childExecutor.close(exit) :
+          undefined
+      ),
+      fin1
+    ]
+    const result = fins.reduce(
+      (acc: Effect.Effect<R, never, Exit.Exit<unknown, unknown>> | undefined, next) => {
+        if (acc !== undefined && next !== undefined) {
+          return Effect.zipWith(
+            acc,
+            Effect.exit(next),
+            (exit1, exit2) => Exit.zipRight(exit1, exit2)
+          )
+        } else if (acc !== undefined) {
+          return acc
+        } else if (next !== undefined) {
+          return Effect.exit(next)
+        } else {
+          return undefined
+        }
+      },
+      undefined
+    )
+    return result === undefined ? result : result
+  }
+
+  enqueuePullFromChild(child: PullFromChild<R>): Subexecutor<R> {
+    return new PullFromUpstream(
+      this.upstreamExecutor,
+      this.createChild,
+      this.lastDone,
+      [...this.activeChildExecutors, child],
+      this.combineChildResults,
+      this.combineWithChildResult,
+      this.onPull,
+      this.onEmit
+    )
+  }
+}
+
+/**
+ * Transformed from `PullFromUpstream` when upstream has finished but there
+ * are still active child executors.
+ *
+ * @internal
+ */
+export class DrainChildExecutors<R> implements Subexecutor<R> {
+  readonly _tag: OP_DRAIN_CHILD_EXECUTORS = OP_DRAIN_CHILD_EXECUTORS
+
+  constructor(
+    readonly upstreamExecutor: ErasedExecutor<R>,
+    readonly lastDone: unknown,
+    readonly activeChildExecutors: ReadonlyArray<PullFromChild<R> | undefined>,
+    readonly upstreamDone: Exit.Exit<unknown, unknown>,
+    readonly combineChildResults: (x: unknown, y: unknown) => unknown,
+    readonly combineWithChildResult: (x: unknown, y: unknown) => unknown,
+    readonly onPull: (
+      request: UpstreamPullRequest.UpstreamPullRequest<unknown>
+    ) => UpstreamPullStrategy.UpstreamPullStrategy<unknown>
+  ) {
+  }
+
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+    const fin1 = this.upstreamExecutor.close(exit)
+    const fins = [
+      ...this.activeChildExecutors.map((child) => (child !== undefined ?
+        child.childExecutor.close(exit) :
+        undefined)
+      ),
+      fin1
+    ]
+    const result = fins.reduce(
+      (acc: Effect.Effect<R, never, Exit.Exit<unknown, unknown>> | undefined, next) => {
+        if (acc !== undefined && next !== undefined) {
+          return Effect.zipWith(
+            acc,
+            Effect.exit(next),
+            (exit1, exit2) => Exit.zipRight(exit1, exit2)
+          )
+        } else if (acc !== undefined) {
+          return acc
+        } else if (next !== undefined) {
+          return Effect.exit(next)
+        } else {
+          return undefined
+        }
+      },
+      undefined
+    )
+    return result === undefined ? result : result
+  }
+
+  enqueuePullFromChild(child: PullFromChild<R>): Subexecutor<R> {
+    return new DrainChildExecutors(
+      this.upstreamExecutor,
+      this.lastDone,
+      [...this.activeChildExecutors, child],
+      this.upstreamDone,
+      this.combineChildResults,
+      this.combineWithChildResult,
+      this.onPull
+    )
+  }
+}
+
+/** @internal */
+export class Emit<R> implements Subexecutor<R> {
+  readonly _tag: OP_EMIT = OP_EMIT
+
+  constructor(readonly value: unknown, readonly next: Subexecutor<R>) {
+  }
+
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+    const result = this.next.close(exit)
+    return result === undefined ? result : result
+  }
+
+  enqueuePullFromChild(_child: PullFromChild<R>): Subexecutor<R> {
+    return this
+  }
+}

package/src/internal/channel/upstreamPullRequest.ts

@@ -0,0 +1,83 @@
+import type * as UpstreamPullRequest from "../../ChannelUpstreamPullRequest"
+import { dual } from "../../Function"
+import * as OpCodes from "../opCodes/channelUpstreamPullRequest"
+
+/** @internal */
+const UpstreamPullRequestSymbolKey = "effect/ChannelUpstreamPullRequest"
+
+/** @internal */
+export const UpstreamPullRequestTypeId: UpstreamPullRequest.UpstreamPullRequestTypeId = Symbol.for(
+  UpstreamPullRequestSymbolKey
+) as UpstreamPullRequest.UpstreamPullRequestTypeId
+
+/** @internal */
+const upstreamPullRequestVariance = {
+  _A: (_: never) => _
+}
+
+/** @internal */
+const proto = {
+  [UpstreamPullRequestTypeId]: upstreamPullRequestVariance
+}
+
+/** @internal */
+export const Pulled = <A>(value: A): UpstreamPullRequest.UpstreamPullRequest<A> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_PULLED
+  op.value = value
+  return op
+}
+
+/** @internal */
+export const NoUpstream = (activeDownstreamCount: number): UpstreamPullRequest.UpstreamPullRequest<never> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_NO_UPSTREAM
+  op.activeDownstreamCount = activeDownstreamCount
+  return op
+}
+
+/** @internal */
+export const isUpstreamPullRequest = (u: unknown): u is UpstreamPullRequest.UpstreamPullRequest<unknown> =>
+  typeof u === "object" && u != null && UpstreamPullRequestTypeId in u
+
+/** @internal */
+export const isPulled = <A>(
+  self: UpstreamPullRequest.UpstreamPullRequest<A>
+): self is UpstreamPullRequest.Pulled<A> => self._tag === OpCodes.OP_PULLED
+
+/** @internal */
+export const isNoUpstream = <A>(
+  self: UpstreamPullRequest.UpstreamPullRequest<A>
+): self is UpstreamPullRequest.NoUpstream => self._tag === OpCodes.OP_NO_UPSTREAM
+
+/** @internal */
+export const match = dual<
+  <A, Z>(
+    options: {
+      readonly onPulled: (value: A) => Z
+      readonly onNoUpstream: (activeDownstreamCount: number) => Z
+    }
+  ) => (self: UpstreamPullRequest.UpstreamPullRequest<A>) => Z,
+  <A, Z>(
+    self: UpstreamPullRequest.UpstreamPullRequest<A>,
+    options: {
+      readonly onPulled: (value: A) => Z
+      readonly onNoUpstream: (activeDownstreamCount: number) => Z
+    }
+  ) => Z
+>(2, <A, Z>(
+  self: UpstreamPullRequest.UpstreamPullRequest<A>,
+  { onNoUpstream, onPulled }: {
+    readonly onPulled: (value: A) => Z
+    readonly onNoUpstream: (activeDownstreamCount: number) => Z
+  }
+): Z => {
+  switch (self._tag) {
+    case OpCodes.OP_PULLED: {
+      return onPulled(self.value)
+    }
+    case OpCodes.OP_NO_UPSTREAM: {
+      return onNoUpstream(self.activeDownstreamCount)
+    }
+  }
+})

package/src/internal/channel/upstreamPullStrategy.ts

@@ -0,0 +1,86 @@
+import type * as UpstreamPullStrategy from "../../ChannelUpstreamPullStrategy"
+import { dual } from "../../Function"
+import type * as Option from "../../Option"
+import * as OpCodes from "../opCodes/channelUpstreamPullStrategy"
+
+/** @internal */
+const UpstreamPullStrategySymbolKey = "effect/ChannelUpstreamPullStrategy"
+
+/** @internal */
+export const UpstreamPullStrategyTypeId: UpstreamPullStrategy.UpstreamPullStrategyTypeId = Symbol.for(
+  UpstreamPullStrategySymbolKey
+) as UpstreamPullStrategy.UpstreamPullStrategyTypeId
+
+/** @internal */
+const upstreamPullStrategyVariance = {
+  _A: (_: never) => _
+}
+
+/** @internal */
+const proto = {
+  [UpstreamPullStrategyTypeId]: upstreamPullStrategyVariance
+}
+
+/** @internal */
+export const PullAfterNext = <A>(emitSeparator: Option.Option<A>): UpstreamPullStrategy.UpstreamPullStrategy<A> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_PULL_AFTER_NEXT
+  op.emitSeparator = emitSeparator
+  return op
+}
+
+/** @internal */
+export const PullAfterAllEnqueued = <A>(
+  emitSeparator: Option.Option<A>
+): UpstreamPullStrategy.UpstreamPullStrategy<A> => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_PULL_AFTER_ALL_ENQUEUED
+  op.emitSeparator = emitSeparator
+  return op
+}
+
+/** @internal */
+export const isUpstreamPullStrategy = (u: unknown): u is UpstreamPullStrategy.UpstreamPullStrategy<unknown> =>
+  typeof u === "object" && u != null && UpstreamPullStrategyTypeId in u
+
+/** @internal */
+export const isPullAfterNext = <A>(
+  self: UpstreamPullStrategy.UpstreamPullStrategy<A>
+): self is UpstreamPullStrategy.PullAfterNext<A> => self._tag === OpCodes.OP_PULL_AFTER_NEXT
+
+/** @internal */
+export const isPullAfterAllEnqueued = <A>(
+  self: UpstreamPullStrategy.UpstreamPullStrategy<A>
+): self is UpstreamPullStrategy.PullAfterAllEnqueued<A> => self._tag === OpCodes.OP_PULL_AFTER_ALL_ENQUEUED
+
+/** @internal */
+export const match = dual<
+  <A, Z>(
+    options: {
+      readonly onNext: (emitSeparator: Option.Option<A>) => Z
+      readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
+    }
+  ) => (self: UpstreamPullStrategy.UpstreamPullStrategy<A>) => Z,
+  <A, Z>(
+    self: UpstreamPullStrategy.UpstreamPullStrategy<A>,
+    options: {
+      readonly onNext: (emitSeparator: Option.Option<A>) => Z
+      readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
+    }
+  ) => Z
+>(2, <A, Z>(
+  self: UpstreamPullStrategy.UpstreamPullStrategy<A>,
+  { onAllEnqueued, onNext }: {
+    readonly onNext: (emitSeparator: Option.Option<A>) => Z
+    readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
+  }
+): Z => {
+  switch (self._tag) {
+    case OpCodes.OP_PULL_AFTER_NEXT: {
+      return onNext(self.emitSeparator)
+    }
+    case OpCodes.OP_PULL_AFTER_ALL_ENQUEUED: {
+      return onAllEnqueued(self.emitSeparator)
+    }
+  }
+})