effect 3.4.9 → 3.5.0

package/src/Stream.ts

@@ -30,7 +30,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant, NoInfer, TupleOf } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -146,6 +146,7 @@ export declare namespace Stream {
   /**
    * @since 2.0.0
    * @category models
+   * @deprecated use Types.TupleOf instead
    */
   export type DynamicTuple<T, N extends number> = N extends N ? number extends N ? Array<T> : DynamicTupleOf<T, N, []>
     : never
@@ -153,6 +154,7 @@ export declare namespace Stream {
   /**
    * @since 2.0.0
    * @category models
+   * @deprecated use Types.TupleOf instead
    */
   export type DynamicTupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R
     : DynamicTupleOf<T, N, [T, ...R]>
@@ -310,7 +312,10 @@ export const as: {
 
 const _async: <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<void, never, R> | void,
-  outputBuffer?: number
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ) => Stream<A, E, R> = internal._async
 
 export {
@@ -362,7 +367,10 @@ export {
  */
 export const asyncEffect: <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>,
-  outputBuffer?: number
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ) => Stream<A, E, R> = internal.asyncEffect
 
 /**
@@ -376,7 +384,10 @@ export const asyncEffect: <A, E = never, R = never>(
  */
 export const asyncScoped: <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>,
-  outputBuffer?: number
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ) => Stream<A, E, Exclude<R, Scope.Scope>> = internal.asyncScoped
 
 /**
@@ -484,12 +495,12 @@ export const broadcast: {
     maximumLag: number
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
+  ) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ): Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
+  ): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
 } = internal.broadcast
 
 /**
@@ -521,12 +532,12 @@ export const broadcastedQueues: {
     maximumLag: number
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>
+  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, R | Scope.Scope>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
+  ): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
 } = internal.broadcastedQueues
 
 /**
@@ -1139,7 +1150,7 @@ export const distributedWith: {
     }
   ): <E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
+  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     options: {
@@ -1147,7 +1158,7 @@ export const distributedWith: {
       readonly maximumLag: number
       readonly decide: (a: A) => Effect.Effect<Predicate<number>>
     }
-  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
+  ): Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>
 } = internal.distributedWith
 
 /**
@@ -2843,8 +2854,8 @@ export const mergeEither: {
  * @category utils
  */
 export const mergeLeft: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>
 } = internal.mergeLeft
 
 /**
@@ -2855,8 +2866,8 @@ export const mergeLeft: {
  * @category utils
  */
 export const mergeRight: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>
 } = internal.mergeRight
 
 /**
@@ -3357,6 +3368,40 @@ export const provideSomeLayer: {
   ): Stream<A, E | E2, RIn | Exclude<R, ROut>>
 } = internal.provideSomeLayer
 
+/**
+ * Returns a stream that mirrors the first upstream to emit an item.
+ * As soon as one of the upstream emits a first value, all the others are interrupted.
+ * The resulting stream will forward all items from the "winning" source stream.
+ * Any upstream failures will cause the returned stream to fail.
+ *
+ * @example
+ * import { Stream, Schedule, Console, Effect } from "effect"
+ *
+ * const stream = Stream.raceAll(
+ *   Stream.fromSchedule(Schedule.spaced('1 millis')),
+ *   Stream.fromSchedule(Schedule.spaced('2 millis')),
+ *   Stream.fromSchedule(Schedule.spaced('4 millis')),
+ * ).pipe(Stream.take(6), Stream.tap(Console.log))
+ *
+ * Effect.runPromise(Stream.runDrain(stream))
+ * // Output each millisecond from the first stream, the rest streams are interrupted
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * @since 3.5.0
+ * @category racing
+ */
+export const raceAll: <S extends ReadonlyArray<Stream<any, any, any>>>(
+  ...streams: S
+) => Stream<
+  Stream.Success<S[number]>,
+  Stream.Error<S[number]>,
+  Stream.Context<S[number]>
+> = internal.raceAll
+
 /**
  * Constructs a stream from a range of integers, including both endpoints.
  *
@@ -3638,7 +3683,7 @@ export const run: {
   <A, E, R, A2, E2, R2>(
     self: Stream<A, E, R>,
     sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): Effect.Effect<A2, E | E2, R | R2>
+  ): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>>
 } = internal.run
 
 /**
@@ -3647,7 +3692,8 @@ export const run: {
  * @since 2.0.0
  * @category destructors
  */
-export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R> = internal.runCollect
+export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, Exclude<R, Scope.Scope>> =
+  internal.runCollect
 
 /**
  * Runs the stream and emits the number of elements processed
@@ -3655,7 +3701,8 @@ export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk
  * @since 2.0.0
  * @category destructors
  */
-export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R> = internal.runCount
+export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, Exclude<R, Scope.Scope>> =
+  internal.runCount
 
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
@@ -3663,7 +3710,8 @@ export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number,
  * @since 2.0.0
  * @category destructors
  */
-export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R> = internal.runDrain
+export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>> =
+  internal.runDrain
 
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
@@ -3673,8 +3721,8 @@ export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E
  * @category destructors
  */
 export const runFold: {
-  <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
-  <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
+  <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>
 } = internal.runFold
 
 /**
@@ -3687,12 +3735,12 @@ export const runFoldEffect: {
   <S, A, E2, R2>(
     s: S,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
   <A, E, R, S, E2, R2>(
     self: Stream<A, E, R>,
     s: S,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): Effect.Effect<S, E | E2, R | R2>
+  ): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>
 } = internal.runFoldEffect
 
 /**
@@ -3734,8 +3782,17 @@ export const runFoldScopedEffect: {
  * @category destructors
  */
 export const runFoldWhile: {
-  <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
-  <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
+  <S, A>(
+    s: S,
+    cont: Predicate<S>,
+    f: (s: S, a: A) => S
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <A, E, R, S>(
+    self: Stream<A, E, R>,
+    s: S,
+    cont: Predicate<S>,
+    f: (s: S, a: A) => S
+  ): Effect.Effect<S, E, Exclude<R, Scope.Scope>>
 } = internal.runFoldWhile
 
 /**
@@ -3750,13 +3807,13 @@ export const runFoldWhileEffect: {
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
   <A, E, R, S, E2, R2>(
     self: Stream<A, E, R>,
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): Effect.Effect<S, E | E2, R | R2>
+  ): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>
 } = internal.runFoldWhileEffect
 
 /**

package/src/index.ts

@@ -605,6 +605,16 @@ export * as Random from "./Random.js"
  */
 export * as RateLimiter from "./RateLimiter.js"
 
+/**
+ * @since 3.5.0
+ */
+export * as RcMap from "./RcMap.js"
+
+/**
+ * @since 3.5.0
+ */
+export * as RcRef from "./RcRef.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/cause.ts

@@ -970,25 +970,46 @@ export const reduceWithContext = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const pretty = <E>(cause: Cause.Cause<E>): string => {
+export const pretty = <E>(cause: Cause.Cause<E>, options?: {
+  readonly renderErrorCause?: boolean | undefined
+}): string => {
   if (isInterruptedOnly(cause)) {
     return "All fibers interrupted without errors."
   }
-  return prettyErrors<E>(cause).map((e) => e.stack).join("\n")
+  return prettyErrors<E>(cause).map(function(e) {
+    if (options?.renderErrorCause !== true || e.cause === undefined) {
+      return e.stack
+    }
+    return `${e.stack} {\n${renderErrorCause(e.cause as PrettyError, "  ")}\n}`
+  }).join("\n")
+}
+
+const renderErrorCause = (cause: PrettyError, prefix: string) => {
+  const lines = cause.stack!.split("\n")
+  let stack = `${prefix}[cause]: ${lines[0]}`
+  for (let i = 1, len = lines.length; i < len; i++) {
+    stack += `\n${prefix}${lines[i]}`
+  }
+  return stack
 }
 
 class PrettyError extends globalThis.Error implements Cause.PrettyError {
   span: undefined | Span = undefined
   constructor(originalError: unknown) {
+    const originalErrorIsObject = typeof originalError === "object" && originalError !== null
     const prevLimit = Error.stackTraceLimit
-    Error.stackTraceLimit = 0
-    super(prettyErrorMessage(originalError))
+    Error.stackTraceLimit = 1
+    super(prettyErrorMessage(originalError), {
+      cause: originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
+        ? new PrettyError(originalError.cause)
+        : undefined
+    })
     if (this.message === "") {
       this.message = "An error has occurred"
     }
     Error.stackTraceLimit = prevLimit
     this.name = originalError instanceof Error ? originalError.name : "Error"
-    if (typeof originalError === "object" && originalError !== null) {
+    if (originalErrorIsObject) {
       if (spanSymbol in originalError) {
         this.span = originalError[spanSymbol] as Span
       }

package/src/internal/channel/channelExecutor.ts

@@ -1095,7 +1095,7 @@ export const readUpstream = <A, E2, R, E>(
 /** @internal */
 export const run = <Env, InErr, InDone, OutErr, OutDone>(
   self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => pipe(runScoped(self), Effect.scoped)
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => pipe(runScoped(self), Effect.scoped)
 
 /** @internal */
 export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(

package/src/internal/channel.ts

@@ -2052,17 +2052,18 @@ export const repeated = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
 /** @internal */
 export const run = <OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => Effect.scoped(executor.runScoped(self))
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => Effect.scoped(executor.runScoped(self))
 
 /** @internal */
 export const runCollect = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Env> => executor.run(core.collectElements(self))
+): Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Exclude<Env, Scope.Scope>> =>
+  executor.run(core.collectElements(self))
 
 /** @internal */
 export const runDrain = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => executor.run(drain(self))
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => executor.run(drain(self))
 
 /** @internal */
 export const scoped = <A, E, R>(

package/src/internal/core-effect.ts

@@ -911,11 +911,6 @@ export const logWithLevel = (level?: LogLevel.LogLevel) =>
       i--
     }
   }
-  if (message.length === 0) {
-    message = "" as any
-  } else if (message.length === 1) {
-    message = message[0]
-  }
   if (cause === undefined) {
     cause = internalCause.empty
   }

package/src/internal/core.ts

@@ -2174,23 +2174,19 @@ export const causeSquashWith = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const YieldableError: new(message?: string) => Cause.YieldableError = (function() {
+export const YieldableError: new(message?: string, options?: ErrorOptions) => Cause.YieldableError = (function() {
   class YieldableError extends globalThis.Error {
     commit() {
       return fail(this)
     }
-    toString() {
-      return this.message ? `${this.name}: ${this.message}` : this.name
-    }
     toJSON() {
       return { ...this }
     }
-    [NodeInspectSymbol](): string {
-      const stack = this.stack
-      if (stack) {
-        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString()
       }
-      return this.toString()
+      return this
     }
   }
   Object.assign(YieldableError.prototype, StructuralCommitPrototype)
@@ -2274,6 +2270,20 @@ export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubC
   [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
 }, "InvalidPubSubCapacityException")
 
+/** @internal */
+export const ExceededCapacityExceptionTypeId: Cause.ExceededCapacityExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/ExceededCapacityException"
+) as Cause.ExceededCapacityExceptionTypeId
+
+/** @internal */
+export const ExceededCapacityException = makeException<Cause.ExceededCapacityException>({
+  [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}, "ExceededCapacityException")
+
+/** @internal */
+export const isExceededCapacityException = (u: unknown): u is Cause.ExceededCapacityException =>
+  hasProperty(u, ExceededCapacityExceptionTypeId)
+
 /** @internal */
 export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
   hasProperty(u, InvalidPubSubCapacityExceptionTypeId)

package/src/internal/defaultServices.ts

@@ -22,7 +22,7 @@ export const liveServices: Context.Context<DefaultServices.DefaultServices> = pi
   Context.empty(),
   Context.add(clock.clockTag, clock.make()),
   Context.add(console_.consoleTag, console_.defaultConsole),
-  Context.add(random.randomTag, random.make((Math.random() * 4294967296) >>> 0)),
+  Context.add(random.randomTag, random.make(Math.random())),
   Context.add(configProvider.configProviderTag, configProvider.fromEnv()),
   Context.add(tracer.tracerTag, tracer.nativeTracer)
 )

package/src/internal/fiberRuntime.ts

@@ -1421,6 +1421,12 @@ export const logFmtLogger: Logger<unknown, void> = globalValue(
   () => loggerWithConsoleLog(internalLogger.logfmtLogger)
 )
 
+/** @internal */
+export const prettyLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/prettyLogger"),
+  () => internalLogger.prettyLogger()
+)
+
 /** @internal */
 export const structuredLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/structuredLogger"),