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

package/src/internal/channel/mergeStrategy.ts

@@ -0,0 +1,72 @@
+import { dual } from "../../Function.js"
+import type * as MergeStrategy from "../../MergeStrategy.js"
+import { hasProperty } from "../../Predicate.js"
+import * as OpCodes from "../opCodes/channelMergeStrategy.js"
+
+/** @internal */
+const MergeStrategySymbolKey = "effect/ChannelMergeStrategy"
+
+/** @internal */
+export const MergeStrategyTypeId: MergeStrategy.MergeStrategyTypeId = Symbol.for(
+  MergeStrategySymbolKey
+) as MergeStrategy.MergeStrategyTypeId
+
+/** @internal */
+const proto = {
+  [MergeStrategyTypeId]: MergeStrategyTypeId
+}
+
+/** @internal */
+export const BackPressure = (_: void): MergeStrategy.MergeStrategy => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_BACK_PRESSURE
+  return op
+}
+
+/** @internal */
+export const BufferSliding = (_: void): MergeStrategy.MergeStrategy => {
+  const op = Object.create(proto)
+  op._tag = OpCodes.OP_BUFFER_SLIDING
+  return op
+}
+
+/** @internal */
+export const isMergeStrategy = (u: unknown): u is MergeStrategy.MergeStrategy => hasProperty(u, MergeStrategyTypeId)
+
+/** @internal */
+export const isBackPressure = (self: MergeStrategy.MergeStrategy): self is MergeStrategy.BackPressure =>
+  self._tag === OpCodes.OP_BACK_PRESSURE
+
+/** @internal */
+export const isBufferSliding = (self: MergeStrategy.MergeStrategy): self is MergeStrategy.BufferSliding =>
+  self._tag === OpCodes.OP_BUFFER_SLIDING
+
+/** @internal */
+export const match = dual<
+  <A>(options: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }) => (self: MergeStrategy.MergeStrategy) => A,
+  <A>(
+    self: MergeStrategy.MergeStrategy,
+    options: {
+      readonly onBackPressure: () => A
+      readonly onBufferSliding: () => A
+    }
+  ) => A
+>(2, <A>(
+  self: MergeStrategy.MergeStrategy,
+  { onBackPressure, onBufferSliding }: {
+    readonly onBackPressure: () => A
+    readonly onBufferSliding: () => A
+  }
+): A => {
+  switch (self._tag) {
+    case OpCodes.OP_BACK_PRESSURE: {
+      return onBackPressure()
+    }
+    case OpCodes.OP_BUFFER_SLIDING: {
+      return onBufferSliding()
+    }
+  }
+})

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -0,0 +1,259 @@
+import * as Cause from "../../Cause.js"
+import * as Deferred from "../../Deferred.js"
+import * as Effect from "../../Effect.js"
+import * as Either from "../../Either.js"
+import * as Exit from "../../Exit.js"
+import { pipe } from "../../Function.js"
+import * as Ref from "../../Ref.js"
+import type * as SingleProducerAsyncInput from "../../SingleProducerAsyncInput.js"
+
+/** @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<void>
+}
+
+/** @internal */
+interface Emit<Err, Elem, Done> {
+  readonly _tag: OP_STATE_EMIT
+  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Elem, Done>, Err>>
+}
+
+/** @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<void>): State<never, never, never> => ({
+  _tag: OP_STATE_EMPTY,
+  notifyProducer
+})
+
+/** @internal */
+const stateEmit = <Err, Elem, Done>(
+  notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Elem, Done>, Err>>
+): 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<in out Err, in out Elem, in out Done>
+  implements SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
+{
+  constructor(readonly ref: Ref.Ref<State<Err, Elem, Done>>) {
+  }
+
+  awaitRead(): Effect.Effect<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.void, state])
+    )
+  }
+
+  get close(): Effect.Effect<unknown> {
+    return Effect.fiberIdWith((fiberId) => this.error(Cause.interrupt(fiberId)))
+  }
+
+  done(value: Done): Effect.Effect<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<unknown> {
+    return Effect.flatMap(Deferred.make<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/effect/issues"
+              )
+            }
+            case OP_STATE_ERROR: {
+              return [Effect.interrupt, state]
+            }
+            case OP_STATE_DONE: {
+              return [Effect.interrupt, state]
+            }
+          }
+        })
+      ))
+  }
+
+  error(cause: Cause.Cause<Err>): Effect.Effect<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]
+          }
+        }
+      })
+    )
+  }
+
+  get take(): Effect.Effect<Exit.Exit<Elem, Either.Either<Done, Err>>> {
+    return this.takeWith(
+      (cause) => Exit.failCause(Cause.map(cause, Either.left)),
+      (elem) => Exit.succeed(elem) as Exit.Exit<Elem, Either.Either<Done, Err>>,
+      (done) => Exit.fail(Either.right(done))
+    )
+  }
+
+  takeWith<A>(
+    onError: (cause: Cause.Cause<Err>) => A,
+    onElement: (element: Elem) => A,
+    onDone: (value: Done) => A
+  ): Effect.Effect<A> {
+    return Effect.flatMap(Deferred.make<Either.Either<Elem, Done>, Err>(), (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<
+  SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
+> =>
+  pipe(
+    Deferred.make<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 "../../ChildExecutorDecision.js"
+import * as Effect from "../../Effect.js"
+import * as Exit from "../../Exit.js"
+import { pipe } from "../../Function.js"
+import type * as UpstreamPullRequest from "../../UpstreamPullRequest.js"
+import type * as UpstreamPullStrategy from "../../UpstreamPullStrategy.js"
+import type { ErasedChannel, ErasedExecutor } from "./channelExecutor.js"
+
+/** @internal */
+export interface Subexecutor<in out R> {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | 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<in out 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<unknown, never, R> | 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<in out 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<unknown, never, R> | 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<Exit.Exit<unknown, unknown>, never, R> | 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<in out 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<unknown, never, R> | 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<Exit.Exit<unknown, unknown>, never, R> | 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<in out 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<unknown, never, R> | 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,84 @@
+import { dual } from "../../Function.js"
+import { hasProperty } from "../../Predicate.js"
+import type * as UpstreamPullRequest from "../../UpstreamPullRequest.js"
+import * as OpCodes from "../opCodes/channelUpstreamPullRequest.js"
+
+/** @internal */
+const UpstreamPullRequestSymbolKey = "effect/ChannelUpstreamPullRequest"
+
+/** @internal */
+export const UpstreamPullRequestTypeId: UpstreamPullRequest.UpstreamPullRequestTypeId = Symbol.for(
+  UpstreamPullRequestSymbolKey
+) as UpstreamPullRequest.UpstreamPullRequestTypeId
+
+const upstreamPullRequestVariance = {
+  /* c8 ignore next */
+  _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> =>
+  hasProperty(u, UpstreamPullRequestTypeId)
+
+/** @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)
+    }
+  }
+})