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

package/src/internal/stream/emit.ts

@@ -0,0 +1,123 @@
+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 { pipe } from "../../Function.js"
+import * as Option from "../../Option.js"
+import type * as Queue from "../../Queue.js"
+import type * as Scheduler from "../../Scheduler.js"
+import type * as Emit from "../../StreamEmit.js"
+
+/** @internal */
+export const make = <R, E, A, B>(
+  emit: (f: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>) => Promise<B>
+): Emit.Emit<R, E, A, B> => {
+  const ops: Emit.EmitOps<R, E, A, B> = {
+    chunk(this: Emit.Emit<R, E, A, B>, as: Chunk.Chunk<A>) {
+      return this(Effect.succeed(as))
+    },
+    die<Err>(this: Emit.Emit<R, E, A, B>, defect: Err) {
+      return this(Effect.die(defect))
+    },
+    dieMessage(this: Emit.Emit<R, E, A, B>, message: string) {
+      return this(Effect.dieMessage(message))
+    },
+    done(this: Emit.Emit<R, E, A, B>, exit: Exit.Exit<A, E>) {
+      return this(Effect.suspend(() => Exit.mapBoth(exit, { onFailure: Option.some, onSuccess: Chunk.of })))
+    },
+    end(this: Emit.Emit<R, E, A, B>) {
+      return this(Effect.fail(Option.none()))
+    },
+    fail(this: Emit.Emit<R, E, A, B>, e: E) {
+      return this(Effect.fail(Option.some(e)))
+    },
+    fromEffect(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<A, E, R>) {
+      return this(Effect.mapBoth(effect, { onFailure: Option.some, onSuccess: Chunk.of }))
+    },
+    fromEffectChunk(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<Chunk.Chunk<A>, E, R>) {
+      return this(pipe(effect, Effect.mapError(Option.some)))
+    },
+    halt(this: Emit.Emit<R, E, A, B>, cause: Cause.Cause<E>) {
+      return this(Effect.failCause(pipe(cause, Cause.map(Option.some))))
+    },
+    single(this: Emit.Emit<R, E, A, B>, value: A) {
+      return this(Effect.succeed(Chunk.of(value)))
+    }
+  }
+  return Object.assign(emit, ops)
+}
+
+/** @internal */
+export const makePush = <E, A>(
+  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
+  scheduler: Scheduler.Scheduler
+): Emit.EmitOpsPush<E, A> => {
+  let finished = false
+  let buffer: Array<A> = []
+  let running = false
+  function array(items: ReadonlyArray<A>) {
+    if (finished) return false
+    if (items.length <= 50_000) {
+      buffer.push.apply(buffer, items as Array<A>)
+    } else {
+      for (let i = 0; i < items.length; i++) {
+        buffer.push(items[0])
+      }
+    }
+    if (!running) {
+      running = true
+      scheduler.scheduleTask(flush, 0)
+    }
+    return true
+  }
+  function flush() {
+    running = false
+    if (buffer.length > 0) {
+      queue.unsafeOffer(buffer)
+      buffer = []
+    }
+  }
+  function done(exit: Exit.Exit<A, E>) {
+    if (finished) return
+    finished = true
+    if (exit._tag === "Success") {
+      buffer.push(exit.value)
+    }
+    flush()
+    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
+  }
+  return {
+    single(value: A) {
+      if (finished) return false
+      buffer.push(value)
+      if (!running) {
+        running = true
+        scheduler.scheduleTask(flush, 0)
+      }
+      return true
+    },
+    array,
+    chunk(chunk) {
+      return array(Chunk.toReadonlyArray(chunk))
+    },
+    done,
+    end() {
+      if (finished) return
+      finished = true
+      flush()
+      queue.unsafeOffer(Exit.void)
+    },
+    halt(cause: Cause.Cause<E>) {
+      return done(Exit.failCause(cause))
+    },
+    fail(error: E) {
+      return done(Exit.fail(error))
+    },
+    die<Err>(defect: Err): void {
+      return done(Exit.die(defect))
+    },
+    dieMessage(message: string): void {
+      return done(Exit.die(new Error(message)))
+    }
+  }
+}

package/src/internal/stream/haltStrategy.ts

@@ -0,0 +1,94 @@
+import { dual } from "../../Function.js"
+import type * as HaltStrategy from "../../StreamHaltStrategy.js"
+import * as OpCodes from "../opCodes/streamHaltStrategy.js"
+
+/** @internal */
+export const Left: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_LEFT
+}
+
+/** @internal */
+export const Right: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_RIGHT
+}
+
+/** @internal */
+export const Both: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_BOTH
+}
+
+/** @internal */
+export const Either: HaltStrategy.HaltStrategy = {
+  _tag: OpCodes.OP_EITHER
+}
+
+/** @internal */
+export const fromInput = (input: HaltStrategy.HaltStrategyInput): HaltStrategy.HaltStrategy => {
+  switch (input) {
+    case "left":
+      return Left
+    case "right":
+      return Right
+    case "both":
+      return Both
+    case "either":
+      return Either
+    default:
+      return input
+  }
+}
+
+/** @internal */
+export const isLeft = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Left => self._tag === OpCodes.OP_LEFT
+
+/** @internal */
+export const isRight = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Right => self._tag === OpCodes.OP_RIGHT
+
+/** @internal */
+export const isBoth = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Both => self._tag === OpCodes.OP_BOTH
+
+/** @internal */
+export const isEither = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Either =>
+  self._tag === OpCodes.OP_EITHER
+
+/** @internal */
+export const match = dual<
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }) => (self: HaltStrategy.HaltStrategy) => Z,
+  <Z>(
+    self: HaltStrategy.HaltStrategy,
+    options: {
+      readonly onLeft: () => Z
+      readonly onRight: () => Z
+      readonly onBoth: () => Z
+      readonly onEither: () => Z
+    }
+  ) => Z
+>(2, <Z>(
+  self: HaltStrategy.HaltStrategy,
+  options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }
+): Z => {
+  switch (self._tag) {
+    case OpCodes.OP_LEFT: {
+      return options.onLeft()
+    }
+    case OpCodes.OP_RIGHT: {
+      return options.onRight()
+    }
+    case OpCodes.OP_BOTH: {
+      return options.onBoth()
+    }
+    case OpCodes.OP_EITHER: {
+      return options.onEither()
+    }
+  }
+})

package/src/internal/stream/handoff.ts

@@ -0,0 +1,187 @@
+import * as Deferred from "../../Deferred.js"
+import * as Effect from "../../Effect.js"
+import { dual, pipe } from "../../Function.js"
+import * as Option from "../../Option.js"
+import * as Ref from "../../Ref.js"
+
+/** @internal */
+export const HandoffTypeId = Symbol.for("effect/Stream/Handoff")
+
+/** @internal */
+export type HandoffTypeId = typeof HandoffTypeId
+
+/**
+ * A synchronous queue-like abstraction that allows a producer to offer an
+ * element and wait for it to be taken, and allows a consumer to wait for an
+ * element to be available.
+ *
+ * @internal
+ */
+export interface Handoff<in out A> extends Handoff.Variance<A> {
+  readonly ref: Ref.Ref<Handoff.State<A>>
+}
+
+/** @internal */
+export const OP_HANDOFF_STATE_EMPTY = "Empty" as const
+
+/** @internal */
+export type OP_HANDOFF_STATE_EMPTY = typeof OP_HANDOFF_STATE_EMPTY
+
+/** @internal */
+export const OP_HANDOFF_STATE_FULL = "Full" as const
+
+/** @internal */
+export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL
+
+/** @internal */
+export declare namespace Handoff {
+  /** @internal */
+  export interface Variance<in out A> {
+    readonly [HandoffTypeId]: {
+      readonly _A: (_: A) => A
+    }
+  }
+
+  /** @internal */
+  export type State<A> = Empty | Full<A>
+
+  /** @internal */
+  export interface Empty {
+    readonly _tag: OP_HANDOFF_STATE_EMPTY
+    readonly notifyConsumer: Deferred.Deferred<void>
+  }
+
+  /** @internal */
+  export interface Full<out A> {
+    readonly _tag: OP_HANDOFF_STATE_FULL
+    readonly value: A
+    readonly notifyProducer: Deferred.Deferred<void>
+  }
+}
+
+/** @internal */
+const handoffStateEmpty = <A>(notifyConsumer: Deferred.Deferred<void>): Handoff.State<A> => ({
+  _tag: OP_HANDOFF_STATE_EMPTY,
+  notifyConsumer
+})
+
+/** @internal */
+const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<void>): Handoff.State<A> => ({
+  _tag: OP_HANDOFF_STATE_FULL,
+  value,
+  notifyProducer
+})
+
+/** @internal */
+const handoffStateMatch = <A, Z>(
+  onEmpty: (notifyConsumer: Deferred.Deferred<void>) => Z,
+  onFull: (value: A, notifyProducer: Deferred.Deferred<void>) => Z
+) => {
+  return (self: Handoff.State<A>): Z => {
+    switch (self._tag) {
+      case OP_HANDOFF_STATE_EMPTY: {
+        return onEmpty(self.notifyConsumer)
+      }
+      case OP_HANDOFF_STATE_FULL: {
+        return onFull(self.value, self.notifyProducer)
+      }
+    }
+  }
+}
+
+const handoffVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+/** @internal */
+export const make = <A>(): Effect.Effect<Handoff<A>> =>
+  pipe(
+    Deferred.make<void>(),
+    Effect.flatMap((deferred) => Ref.make(handoffStateEmpty<A>(deferred))),
+    Effect.map((ref): Handoff<A> => ({
+      [HandoffTypeId]: handoffVariance,
+      ref
+    }))
+  )
+
+/** @internal */
+export const offer = dual<
+  <A>(value: A) => (self: Handoff<A>) => Effect.Effect<void>,
+  <A>(self: Handoff<A>, value: A) => Effect.Effect<void>
+>(2, (self, value): Effect.Effect<void> => {
+  return Effect.flatMap(Deferred.make<void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            (notifyConsumer) => [
+              Effect.zipRight(
+                Deferred.succeed(notifyConsumer, void 0),
+                Deferred.await(deferred)
+              ),
+              handoffStateFull(value, deferred)
+            ],
+            (_, notifyProducer) => [
+              Effect.flatMap(
+                Deferred.await(notifyProducer),
+                () => pipe(self, offer(value))
+              ),
+              state
+            ]
+          )
+        ))
+    ))
+})
+
+/** @internal */
+export const take = <A>(self: Handoff<A>): Effect.Effect<A> =>
+  Effect.flatMap(Deferred.make<void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            (notifyConsumer) =>
+              [
+                Effect.flatMap(
+                  Deferred.await(notifyConsumer),
+                  () => take(self)
+                ),
+                state
+              ] as const,
+            (value, notifyProducer) => [
+              Effect.as(
+                Deferred.succeed(notifyProducer, void 0),
+                value
+              ),
+              handoffStateEmpty<A>(deferred)
+            ]
+          )
+        ))
+    ))
+
+/** @internal */
+export const poll = <A>(self: Handoff<A>): Effect.Effect<Option.Option<A>> =>
+  Effect.flatMap(Deferred.make<void>(), (deferred) =>
+    Effect.flatten(
+      Ref.modify(self.ref, (state) =>
+        pipe(
+          state,
+          handoffStateMatch(
+            () =>
+              [
+                Effect.succeed(Option.none<A>()),
+                state
+              ] as const,
+            (value, notifyProducer) => [
+              Effect.as(
+                Deferred.succeed(notifyProducer, void 0),
+                Option.some(value)
+              ),
+              handoffStateEmpty<A>(deferred)
+            ]
+          )
+        ))
+    ))

package/src/internal/stream/handoffSignal.ts

@@ -0,0 +1,59 @@
+import type * as Cause from "../../Cause.js"
+import type * as Chunk from "../../Chunk.js"
+import type * as SinkEndReason from "./sinkEndReason.js"
+
+/** @internal */
+export type HandoffSignal<A, E = never> = Emit<A> | Halt<E> | End
+
+/** @internal */
+export const OP_EMIT = "Emit" as const
+
+/** @internal */
+export type OP_EMIT = typeof OP_EMIT
+
+/** @internal */
+export const OP_HALT = "Halt" as const
+
+/** @internal */
+export type OP_HALT = typeof OP_HALT
+
+/** @internal */
+export const OP_END = "End" as const
+
+/** @internal */
+export type OP_END = typeof OP_END
+
+export interface Emit<out A> {
+  readonly _tag: OP_EMIT
+  readonly elements: Chunk.Chunk<A>
+}
+
+/** @internal */
+export interface Halt<out E> {
+  readonly _tag: OP_HALT
+  readonly cause: Cause.Cause<E>
+}
+
+/** @internal */
+export interface End {
+  readonly _tag: OP_END
+  readonly reason: SinkEndReason.SinkEndReason
+}
+
+/** @internal */
+export const emit = <A>(elements: Chunk.Chunk<A>): HandoffSignal<A> => ({
+  _tag: OP_EMIT,
+  elements
+})
+
+/** @internal */
+export const halt = <E>(cause: Cause.Cause<E>): HandoffSignal<never, E> => ({
+  _tag: OP_HALT,
+  cause
+})
+
+/** @internal */
+export const end = (reason: SinkEndReason.SinkEndReason): HandoffSignal<never> => ({
+  _tag: OP_END,
+  reason
+})

package/src/internal/stream/pull.ts

@@ -0,0 +1,34 @@
+import type * as Cause from "../../Cause.js"
+import * as Chunk from "../../Chunk.js"
+import * as Effect from "../../Effect.js"
+import * as Option from "../../Option.js"
+import * as Queue from "../../Queue.js"
+import type * as Take from "../../Take.js"
+import * as take from "../take.js"
+
+/** @internal */
+export interface Pull<out R, out E, out A> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
+
+/** @internal */
+export const emit = <A>(value: A): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))
+
+/** @internal */
+export const emitChunk = <A>(chunk: Chunk.Chunk<A>): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(chunk)
+
+/** @internal */
+export const empty = <A>(): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.empty<A>())
+
+/** @internal */
+export const end = (): Effect.Effect<never, Option.Option<never>> => Effect.fail(Option.none())
+
+/** @internal */
+export const fail = <E>(error: E): Effect.Effect<never, Option.Option<E>> => Effect.fail(Option.some(error))
+
+/** @internal */
+export const failCause = <E>(cause: Cause.Cause<E>): Effect.Effect<never, Option.Option<E>> =>
+  Effect.mapError(Effect.failCause(cause), Option.some)
+
+/** @internal */
+export const fromDequeue = <A, E>(
+  dequeue: Queue.Dequeue<Take.Take<A, E>>
+): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> => Effect.flatMap(Queue.take(dequeue), take.done)

package/src/internal/stream/sinkEndReason.ts

@@ -0,0 +1,30 @@
+/** @internal */
+export type SinkEndReason = ScheduleEnd | UpstreamEnd
+
+/** @internal */
+export const OP_SCHEDULE_END = "ScheduleEnd" as const
+
+/** @internal */
+export type OP_SCHEDULE_END = typeof OP_SCHEDULE_END
+
+/** @internal */
+export const OP_UPSTREAM_END = "UpstreamEnd" as const
+
+/** @internal */
+export type OP_UPSTREAM_END = typeof OP_UPSTREAM_END
+
+/** @internal */
+export interface ScheduleEnd {
+  readonly _tag: OP_SCHEDULE_END
+}
+
+/** @internal */
+export interface UpstreamEnd {
+  readonly _tag: OP_UPSTREAM_END
+}
+
+/** @internal */
+export const ScheduleEnd: SinkEndReason = { _tag: OP_SCHEDULE_END }
+
+/** @internal */
+export const UpstreamEnd: SinkEndReason = { _tag: OP_UPSTREAM_END }

package/src/internal/stream/zipAllState.ts

@@ -0,0 +1,88 @@
+import type * as Chunk from "../../Chunk.js"
+
+/** @internal */
+export type ZipAllState<A, A2> = DrainLeft | DrainRight | PullBoth | PullLeft<A2> | PullRight<A>
+
+/** @internal */
+export const OP_DRAIN_LEFT = "DrainLeft" as const
+
+/** @internal */
+export type OP_DRAIN_LEFT = typeof OP_DRAIN_LEFT
+
+/** @internal */
+export const OP_DRAIN_RIGHT = "DrainRight" as const
+
+/** @internal */
+export type OP_DRAIN_RIGHT = typeof OP_DRAIN_RIGHT
+
+/** @internal */
+export const OP_PULL_BOTH = "PullBoth" as const
+
+/** @internal */
+export type OP_PULL_BOTH = typeof OP_PULL_BOTH
+
+/** @internal */
+export const OP_PULL_LEFT = "PullLeft" as const
+
+/** @internal */
+export type OP_PULL_LEFT = typeof OP_PULL_LEFT
+
+/** @internal */
+export const OP_PULL_RIGHT = "PullRight" as const
+
+/** @internal */
+export type OP_PULL_RIGHT = typeof OP_PULL_RIGHT
+
+/** @internal */
+export interface DrainLeft {
+  readonly _tag: OP_DRAIN_LEFT
+}
+
+/** @internal */
+export interface DrainRight {
+  readonly _tag: OP_DRAIN_RIGHT
+}
+
+/** @internal */
+export interface PullBoth {
+  readonly _tag: OP_PULL_BOTH
+}
+
+/** @internal */
+export interface PullLeft<A> {
+  readonly _tag: OP_PULL_LEFT
+  readonly rightChunk: Chunk.Chunk<A>
+}
+
+/** @internal */
+export interface PullRight<A> {
+  readonly _tag: OP_PULL_RIGHT
+  readonly leftChunk: Chunk.Chunk<A>
+}
+
+/** @internal */
+export const DrainLeft: ZipAllState<never, never> = {
+  _tag: OP_DRAIN_LEFT
+}
+
+/** @internal */
+export const DrainRight: ZipAllState<never, never> = {
+  _tag: OP_DRAIN_RIGHT
+}
+
+/** @internal */
+export const PullBoth: ZipAllState<never, never> = {
+  _tag: OP_PULL_BOTH
+}
+
+/** @internal */
+export const PullLeft = <A>(rightChunk: Chunk.Chunk<A>): ZipAllState<never, A> => ({
+  _tag: OP_PULL_LEFT,
+  rightChunk
+})
+
+/** @internal */
+export const PullRight = <A>(leftChunk: Chunk.Chunk<A>): ZipAllState<A, never> => ({
+  _tag: OP_PULL_RIGHT,
+  leftChunk
+})

package/src/internal/stream/zipChunksState.ts

@@ -0,0 +1,56 @@
+import type * as Chunk from "../../Chunk.js"
+
+/** @internal */
+export type ZipChunksState<A, A2> = PullBoth | PullLeft<A2> | PullRight<A>
+
+/** @internal */
+export const OP_PULL_BOTH = "PullBoth" as const
+
+/** @internal */
+export type OP_PULL_BOTH = typeof OP_PULL_BOTH
+
+/** @internal */
+export const OP_PULL_LEFT = "PullLet" as const
+
+/** @internal */
+export type OP_PULL_LEFT = typeof OP_PULL_LEFT
+
+/** @internal */
+export const OP_PULL_RIGHT = "PullRight" as const
+
+/** @internal */
+export type OP_PULL_RIGHT = typeof OP_PULL_RIGHT
+
+/** @internal */
+export interface PullBoth {
+  readonly _tag: OP_PULL_BOTH
+}
+
+/** @internal */
+export interface PullLeft<A> {
+  readonly _tag: OP_PULL_LEFT
+  readonly rightChunk: Chunk.Chunk<A>
+}
+
+/** @internal */
+export interface PullRight<A> {
+  readonly _tag: OP_PULL_RIGHT
+  readonly leftChunk: Chunk.Chunk<A>
+}
+
+/** @internal */
+export const PullBoth: ZipChunksState<never, never> = {
+  _tag: OP_PULL_BOTH
+}
+
+/** @internal */
+export const PullLeft = <A>(rightChunk: Chunk.Chunk<A>): ZipChunksState<never, A> => ({
+  _tag: OP_PULL_LEFT,
+  rightChunk
+})
+
+/** @internal */
+export const PullRight = <A>(leftChunk: Chunk.Chunk<A>): ZipChunksState<A, never> => ({
+  _tag: OP_PULL_RIGHT,
+  leftChunk
+})