effect 3.2.9 → 3.3.1

package/src/Stream.ts

@@ -3860,7 +3860,17 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <A, E>(self: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: {
+  <A>(
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): <E>(
+    self: Stream<A, E>
+  ) => ReadableStream<A>
+  <A, E>(
+    self: Stream<A, E>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): ReadableStream<A>
+} = internal.toReadableStream
 
 /**
  * Converts the stream to a `Effect<ReadableStream>`.
@@ -3870,8 +3880,17 @@ export const toReadableStream: <A, E>(self: Stream<A, E>) => ReadableStream<A> =
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStreamEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<ReadableStream<A>, never, R> =
-  internal.toReadableStreamEffect
+export const toReadableStreamEffect: {
+  <A>(
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): <E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<ReadableStream<A>, never, R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): Effect.Effect<ReadableStream<A>, never, R>
+} = internal.toReadableStreamEffect
 
 /**
  * Converts the stream to a `ReadableStream` using the provided runtime.
@@ -3882,12 +3901,14 @@ export const toReadableStreamEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.
  * @category destructors
  */
 export const toReadableStreamRuntime: {
-  <XR>(
-    runtime: Runtime<XR>
-  ): <A, E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
+  <A, XR>(
+    runtime: Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    runtime: Runtime<XR>
+    runtime: Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ): ReadableStream<A>
 } = internal.toReadableStreamRuntime
 
@@ -4329,6 +4350,45 @@ export const zipLatest: {
   <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
 } = internal.zipLatest
 
+/**
+ * Zips multiple streams so that when a value is emitted by any of the streams,
+ * it is combined with the latest values from the other streams to produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @example
+ * import { Stream, Schedule, Console, Effect } from "effect"
+ *
+ * const stream = Stream.zipLatestAll(
+ *     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:
+ * // [ 0, 0, 0 ]
+ * // [ 1, 0, 0 ]
+ * // [ 1, 1, 0 ]
+ * // [ 2, 1, 0 ]
+ * // [ 3, 1, 0 ]
+ * // [ 3, 1, 1 ]
+ * // .....
+ *
+ * @since 3.3.0
+ * @category zipping
+ */
+export const zipLatestAll: <T extends ReadonlyArray<Stream<any, any, any>>>(
+  ...streams: T
+) => Stream<
+  [T[number]] extends [never] ? never
+    : { [K in keyof T]: T[K] extends Stream<infer A, infer _E, infer _R> ? A : never },
+  [T[number]] extends [never] ? never : T[number] extends Stream<infer _A, infer _E, infer _R> ? _E : never,
+  [T[number]] extends [never] ? never : T[number] extends Stream<infer _A, infer _E, infer _R> ? _R : never
+> = internal.zipLatestAll
+
 /**
  * Zips the two streams so that when a value is emitted by either of the two
  * streams, it is combined with the latest value from the other stream to

package/src/Struct.ts

@@ -119,14 +119,14 @@ export const getOrder: <R extends { readonly [x: string]: order.Order<any> }>(
   fields: R
 ) => order.Order<{ [K in keyof R]: [R[K]] extends [order.Order<infer A>] ? A : never }> = order.struct
 
-type PartialTransform<O> = Partial<{ [K in keyof O]: (a: O[K]) => unknown }>
-
-type Transformed<O, T extends PartialTransform<O>> =
+type Transformed<O, T> =
   & unknown
   & {
-    [K in keyof O]: K extends keyof T ? T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K] : O[K]
+    [K in keyof O]: K extends keyof T ? (T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K]) : O[K]
   }
-
+type PartialTransform<O, T> = {
+  [K in keyof T]: T[K] extends (a: O[K & keyof O]) => any ? T[K] : (a: O[K & keyof O]) => unknown
+}
 /**
  * Transforms the values of a Struct provided a transformation function for each key.
  * If no transformation function is provided for a key, it will return the origional value for that key.
@@ -148,16 +148,11 @@ type Transformed<O, T extends PartialTransform<O>> =
  * @since 2.0.0
  */
 export const evolve: {
-  <O, T extends PartialTransform<O>>(t: T): (
-    obj: O
-  ) => Transformed<O, T>
-  <O, T extends PartialTransform<O>>(obj: O, t: T): Transformed<O, T>
+  <O, T>(t: PartialTransform<O, T>): (obj: O) => Transformed<O, T>
+  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T>
 } = dual(
   2,
-  <O, T extends PartialTransform<O>>(
-    obj: O,
-    t: T
-  ): unknown & Transformed<O, T> => {
+  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T> => {
     const out = { ...obj }
     for (const k in t) {
       if (Object.prototype.hasOwnProperty.call(obj, k)) {

package/src/Tuple.ts

@@ -202,3 +202,56 @@ export const appendElement: {
   - swap
 
 */
+
+export {
+  /**
+   * Determine if an `Array` is a tuple with exactly `N` elements, narrowing down the type to `TupleOf`.
+   *
+   * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
+   *
+   * @example
+   * import { isTupleOf } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 2), false);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3];
+   * if (isTupleOf(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
+  isTupleOf,
+  /**
+   * Determine if an `Array` is a tuple with at least `N` elements, narrowing down the type to `TupleOfAtLeast`.
+   *
+   * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
+   *
+   * @example
+   * import { isTupleOfAtLeast } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 2), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3, 4];
+   * if (isTupleOfAtLeast(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number, ...number[]]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
+  isTupleOfAtLeast
+} from "./Predicate.js"

package/src/Types.ts

@@ -4,6 +4,54 @@
  * @since 2.0.0
  */
 
+type _TupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>
+
+/**
+ * Represents a tuple with a fixed number of elements of type `T`.
+ *
+ * This type constructs a tuple that has exactly `N` elements of type `T`.
+ *
+ * @typeParam N - The number of elements in the tuple.
+ * @typeParam T - The type of elements in the tuple.
+ *
+ * @example
+ * import { TupleOf } from "effect/Types"
+ *
+ * // A tuple with exactly 3 numbers
+ * const example1: TupleOf<3, number> = [1, 2, 3]; // valid
+ * // @ts-expect-error
+ * const example2: TupleOf<3, number> = [1, 2]; // invalid
+ * // @ts-expect-error
+ * const example3: TupleOf<3, number> = [1, 2, 3, 4]; // invalid
+ *
+ * @category tuples
+ * @since 3.3.0
+ */
+export type TupleOf<N extends number, T> = N extends N ? number extends N ? Array<T> : _TupleOf<T, N, []> : never
+
+/**
+ * Represents a tuple with at least `N` elements of type `T`.
+ *
+ * This type constructs a tuple that has a fixed number of elements `N` of type `T` at the start,
+ * followed by any number (including zero) of additional elements of the same type `T`.
+ *
+ * @typeParam N - The minimum number of elements in the tuple.
+ * @typeParam T - The type of elements in the tuple.
+ *
+ * @example
+ * import { TupleOfAtLeast } from "effect/Types"
+ *
+ * // A tuple with at least 3 numbers
+ * const example1: TupleOfAtLeast<3, number> = [1, 2, 3]; // valid
+ * const example2: TupleOfAtLeast<3, number> = [1, 2, 3, 4, 5]; // valid
+ * // @ts-expect-error
+ * const example3: TupleOfAtLeast<3, number> = [1, 2]; // invalid
+ *
+ * @category tuples
+ * @since 3.3.0
+ */
+export type TupleOfAtLeast<N extends number, T> = [...TupleOf<N, T>, ...Array<T>]
+
 /**
  * Returns the tags in a type.
  * @example

package/src/Utils.ts

@@ -172,17 +172,20 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
   readonly _E: Types.Covariant<E>
 }
 
-/**
- * @category models
- * @since 2.0.0
- */
 /**
  * @category models
  * @since 2.0.0
  */
 export interface Gen<F extends TypeLambda, Z> {
-  <K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
-    body: (resume: Z) => Generator<K, A, never>
+  <Self, K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
+    ...args:
+      | [
+        self: Self,
+        body: (this: Self, resume: Z) => Generator<K, A, never>
+      ]
+      | [
+        body: (resume: Z) => Generator<K, A, never>
+      ]
   ): Kind<
     F,
     [K] extends [Variance<F, infer R, any, any>] ? R

package/src/index.ts

@@ -614,6 +614,16 @@ export * as Record from "./Record.js"
  */
 export * as RedBlackTree from "./RedBlackTree.js"
 
+/**
+ * The Redacted module provides functionality for handling sensitive information
+ * securely within your application. By using the `Redacted` data type, you can
+ * ensure that sensitive values are not accidentally exposed in logs or error
+ * messages.
+ *
+ * @since 3.3.0
+ */
+export * as Redacted from "./Redacted.js"
+
 /**
  * @since 2.0.0
  */
@@ -713,6 +723,7 @@ export * as ScopedRef from "./ScopedRef.js"
 
 /**
  * @since 2.0.0
+ * @deprecated
  */
 export * as Secret from "./Secret.js"
 

package/src/internal/config.ts

@@ -10,12 +10,14 @@ import * as HashSet from "../HashSet.js"
 import type * as LogLevel from "../LogLevel.js"
 import * as Option from "../Option.js"
 import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
+import type * as Redacted from "../Redacted.js"
 import type * as Secret from "../Secret.js"
 import * as configError from "./configError.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as effectable from "./effectable.js"
 import * as OpCodes from "./opCodes/config.js"
+import * as redacted_ from "./redacted.js"
 import * as InternalSecret from "./secret.js"
 
 const ConfigSymbolKey = "effect/Config"
@@ -178,8 +180,8 @@ export const boolean = (name?: string): Config.Config<boolean> => {
 }
 
 /** @internal */
-export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<ReadonlyArray<A>> => {
-  return pipe(chunk(config, name), map(Chunk.toReadonlyArray))
+export const array = <A>(config: Config.Config<A>, name?: string): Config.Config<Array<A>> => {
+  return pipe(chunk(config, name), map(Chunk.toArray))
 }
 
 /** @internal */
@@ -421,6 +423,15 @@ export const secret = (name?: string): Config.Config<Secret.Secret> => {
   return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
+export const redacted = (name?: string): Config.Config<Redacted.Redacted> => {
+  const config = primitive(
+    "a redacted property",
+    (text) => Either.right(redacted_.make(text))
+  )
+  return name === undefined ? config : nested(config, name)
+}
+
 /** @internal */
 export const hashSet = <A>(config: Config.Config<A>, name?: string): Config.Config<HashSet.HashSet<A>> => {
   const newConfig = map(chunk(config), HashSet.fromIterable)

package/src/internal/layer.ts

@@ -8,6 +8,7 @@ import type { FiberRef } from "../FiberRef.js"
 import * as FiberRefsPatch from "../FiberRefsPatch.js"
 import type { LazyArg } from "../Function.js"
 import { dual, pipe } from "../Function.js"
+import * as HashMap from "../HashMap.js"
 import type * as Layer from "../Layer.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -1108,10 +1109,72 @@ export const unwrapScoped = <A, E1, R1, E, R>(
   return flatMap(scoped(tag, self), (context) => Context.get(context, tag))
 }
 
+// -----------------------------------------------------------------------------
+// logging
+// -----------------------------------------------------------------------------
+
+export const annotateLogs = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  },
+  {
+    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
+    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
+  }
+>(
+  (args) => isLayer(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return fiberRefLocallyWith(
+      args[0] as Layer.Layer<A, E, R>,
+      core.currentLogAnnotations,
+      typeof args[1] === "string"
+        ? HashMap.set(args[1], args[2])
+        : (annotations) =>
+          Object.entries(args[1] as Record<string, unknown>).reduce(
+            (acc, [key, value]) => HashMap.set(acc, key, value),
+            annotations
+          )
+    )
+  }
+)
+
 // -----------------------------------------------------------------------------
 // tracing
 // -----------------------------------------------------------------------------
 
+export const annotateSpans = dual<
+  {
+    (key: string, value: unknown): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+    (
+      values: Record<string, unknown>
+    ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  },
+  {
+    <A, E, R>(self: Layer.Layer<A, E, R>, key: string, value: unknown): Layer.Layer<A, E, R>
+    <A, E, R>(self: Layer.Layer<A, E, R>, values: Record<string, unknown>): Layer.Layer<A, E, R>
+  }
+>(
+  (args) => isLayer(args[0]),
+  function<A, E, R>() {
+    const args = arguments
+    return fiberRefLocallyWith(
+      args[0] as Layer.Layer<A, E, R>,
+      core.currentTracerSpanAnnotations,
+      typeof args[1] === "string"
+        ? HashMap.set(args[1], args[2])
+        : (annotations) =>
+          Object.entries(args[1] as Record<string, unknown>).reduce(
+            (acc, [key, value]) => HashMap.set(acc, key, value),
+            annotations
+          )
+    )
+  }
+)
+
 /** @internal */
 export const withSpan: {
   (