effect 3.2.8 → 3.3.0

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.2.8";
+let moduleVersion = "3.3.0";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.2.8",
+  "version": "3.3.0",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {
@@ -482,6 +482,11 @@
       "import": "./dist/esm/RedBlackTree.js",
       "default": "./dist/cjs/RedBlackTree.js"
     },
+    "./Redacted": {
+      "types": "./dist/dts/Redacted.d.ts",
+      "import": "./dist/esm/Redacted.js",
+      "default": "./dist/cjs/Redacted.js"
+    },
     "./Ref": {
       "types": "./dist/dts/Ref.d.ts",
       "import": "./dist/esm/Ref.js",
@@ -1081,6 +1086,9 @@
       "RedBlackTree": [
         "./dist/dts/RedBlackTree.d.ts"
       ],
+      "Redacted": [
+        "./dist/dts/Redacted.d.ts"
+      ],
       "Ref": [
         "./dist/dts/Ref.d.ts"
       ],

package/src/Config.ts

@@ -13,6 +13,7 @@ import * as internal from "./internal/config.js"
 import type * as LogLevel from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Redacted from "./Redacted.js"
 import type * as Secret from "./Secret.js"
 import type * as Types from "./Types.js"
 
@@ -69,13 +70,11 @@ export declare namespace Config {
    * @since 2.0.0
    * @category models
    */
-  export type Wrap<A> = [NonNullable<A>] extends [infer T] ? [T] extends [Function] ? Config<A> :
-    [T] extends [ReadonlyArray<infer _>] ? Config<A> :
-    [T] extends [Record<string, any>] ?
-        | {
-          [K in keyof A]: Wrap<A[K]>
-        }
-        | Config<A>
+  export type Wrap<A> = [NonNullable<A>] extends [infer T] ?
+    [T] extends [Record<string, any>] ? [Exclude<keyof T, string>] extends [never] ?
+          | { readonly [K in keyof A]: Wrap<A[K]> }
+          | Config<A>
+      : Config<A>
     : Config<A>
     : Config<A>
 }
@@ -332,9 +331,18 @@ export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
  *
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const secret: (name?: string) => Config<Secret.Secret> = internal.secret
 
+/**
+ * Constructs a config for a redacted value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const redacted: (name?: string) => Config<Redacted.Redacted> = internal.redacted
+
 /**
  * Constructs a config for a sequence of values.
  *

package/src/Context.ts

@@ -89,7 +89,7 @@ export declare namespace Tag {
    * @since 2.0.0
    */
   export type Identifier<T extends Tag<any, any> | TagClassShape<any, any>> = T extends Tag<infer A, any> ? A
-    : T extends TagClassShape<infer A, any> ? A
+    : T extends TagClassShape<any, any> ? T
     : never
 }
 

package/src/Either.ts

@@ -700,7 +700,10 @@ const adapter = Gen.adapter<EitherTypeLambda>()
  * @category generators
  * @since 2.0.0
  */
-export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (f) => {
+export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (...args) => {
+  const f = (args.length === 1)
+    ? args[0]
+    : args[1].bind(args[0])
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {

package/src/Iterable.ts

@@ -265,6 +265,19 @@ export const head = <A>(self: Iterable<A>): Option<A> => {
   return result.done ? O.none() : O.some(result.value)
 }
 
+/**
+ * Get the first element of a `Iterable`, or throw an error if the `Iterable` is empty.
+ *
+ * @category getters
+ * @since 3.3.0
+ */
+export const unsafeHead = <A>(self: Iterable<A>): A => {
+  const iterator = self[Symbol.iterator]()
+  const result = iterator.next()
+  if (result.done) throw new Error("unsafeHead: empty iterable")
+  return result.value
+}
+
 /**
  * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`.
  *

package/src/Layer.ts

@@ -139,6 +139,28 @@ export const isLayer: (u: unknown) => u is Layer<unknown, unknown, unknown> = in
  */
 export const isFresh: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => boolean = internal.isFresh
 
+/**
+ * @since 3.3.0
+ * @category tracing
+ */
+export const annotateLogs: {
+  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
+} = internal.annotateLogs
+
+/**
+ * @since 3.3.0
+ * @category tracing
+ */
+export const annotateSpans: {
+  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
+  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
+} = internal.annotateSpans
+
 /**
  * Builds a layer into a scoped value.
  *

package/src/Option.ts

@@ -1345,7 +1345,13 @@ const adapter = Gen.adapter<OptionTypeLambda>()
  * @category generators
  * @since 2.0.0
  */
-export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (f) => {
+export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (...args) => {
+  let f: any
+  if (args.length === 1) {
+    f = args[0]
+  } else {
+    f = args[1].bind(args[0])
+  }
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {

package/src/Pool.ts

@@ -74,6 +74,16 @@ export const isPool: (u: unknown) => u is Pool<unknown, unknown> = internal.isPo
  * because the `Scope` is closed, the individual items allocated by the pool
  * will be released in some unspecified order.
  *
+ * By setting the `concurrency` parameter, you can control the level of concurrent
+ * access per pool item. By default, the number of permits is set to `1`.
+ *
+ * `targetUtilization` determines when to create new pool items. It is a value
+ * between 0 and 1, where 1 means only create new pool items when all the existing
+ * items are fully utilized.
+ *
+ * A `targetUtilization` of 0.5 will create new pool items when the existing items are
+ * 50% utilized.
+ *
  * @since 2.0.0
  * @category constructors
  */
@@ -81,6 +91,8 @@ export const make: <A, E, R>(
   options: {
     readonly acquire: Effect.Effect<A, E, R>
     readonly size: number
+    readonly concurrency?: number | undefined
+    readonly targetUtilization?: number | undefined
   }
 ) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.make
 
@@ -92,6 +104,22 @@ export const make: <A, E, R>(
  * used, the individual items allocated by the pool will be released in some
  * unspecified order.
  *
+ * By setting the `concurrency` parameter, you can control the level of concurrent
+ * access per pool item. By default, the number of permits is set to `1`.
+ *
+ * `targetUtilization` determines when to create new pool items. It is a value
+ * between 0 and 1, where 1 means only create new pool items when all the existing
+ * items are fully utilized.
+ *
+ * A `targetUtilization` of 0.5 will create new pool items when the existing items are
+ * 50% utilized.
+ *
+ * The `timeToLiveStrategy` determines how items are invalidated. If set to
+ * "creation", then items are invalidated based on their creation time. If set
+ * to "usage", then items are invalidated based on pool usage.
+ *
+ * By default, the `timeToLiveStrategy` is set to "usage".
+ *
  * ```ts
  * import { createConnection } from "mysql2";
  * import { Duration, Effect, Pool } from "effect"
@@ -115,12 +143,17 @@ export const make: <A, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithTTL: <A, E, R>(options: {
-  readonly acquire: Effect.Effect<A, E, R>
-  readonly min: number
-  readonly max: number
-  readonly timeToLive: Duration.DurationInput
-}) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.makeWithTTL
+export const makeWithTTL: <A, E, R>(
+  options: {
+    readonly acquire: Effect.Effect<A, E, R>
+    readonly min: number
+    readonly max: number
+    readonly concurrency?: number | undefined
+    readonly targetUtilization?: number | undefined
+    readonly timeToLive: Duration.DurationInput
+    readonly timeToLiveStrategy?: "creation" | "usage" | undefined
+  }
+) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R> = internal.makeWithTTL
 
 /**
  * Retrieves an item from the pool in a scoped effect. Note that if

package/src/Predicate.ts

@@ -3,6 +3,7 @@
  */
 import { dual, isFunction as isFunction_ } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
+import type { TupleOf, TupleOfAtLeast } from "./Types.js"
 
 /**
  * @category models
@@ -52,6 +53,64 @@ export const mapInput: {
   <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>
 } = dual(2, <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> => (b) => self(f(b)))
 
+/**
+ * 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/Predicate"
+ *
+ * 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
+ */
+export const isTupleOf: {
+  <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOf<N, T>
+  <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T>
+} = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T> => self.length === n)
+
+/**
+ * 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/Predicate"
+ *
+ * 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
+ */
+export const isTupleOfAtLeast: {
+  <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOfAtLeast<N, T>
+  <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T>
+} = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T> => self.length >= n)
+
 /**
  * Tests if a value is `truthy`.
  *

package/src/Redacted.ts

@@ -0,0 +1,79 @@
+/**
+ * @since 3.3.0
+ */
+import type * as Equal from "./Equal.js"
+import * as Equivalence from "./Equivalence.js"
+import * as redacted_ from "./internal/redacted.js"
+import type { Pipeable } from "./Pipeable.js"
+import type { Covariant } from "./Types.js"
+
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export const RedactedTypeId: unique symbol = redacted_.RedactedTypeId
+
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export type RedactedTypeId = typeof RedactedTypeId
+
+/**
+ * @since 3.3.0
+ * @category models
+ */
+export interface Redacted<out A = string> extends Redacted.Variance<A>, Equal.Equal, Pipeable {
+}
+
+/**
+ * @since 3.3.0
+ */
+export declare namespace Redacted {
+  /**
+   * @since 3.3.0
+   * @category models
+   */
+  export interface Variance<out A> {
+    readonly [RedactedTypeId]: {
+      readonly _A: Covariant<A>
+    }
+  }
+
+  /**
+   * @since 3.3.0
+   * @category type-level
+   */
+  export type Value<T extends Redacted<any>> = [T] extends [Redacted<infer _A>] ? _A : never
+}
+
+/**
+ * @since 3.3.0
+ * @category refinements
+ */
+export const isRedacted: (u: unknown) => u is Redacted<unknown> = redacted_.isRedacted
+
+/**
+ * @since 3.3.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Redacted<A> = redacted_.make
+
+/**
+ * @since 3.3.0
+ * @category getters
+ */
+export const value: <A>(self: Redacted<A>) => A = redacted_.value
+
+/**
+ * @since 3.3.0
+ * @category unsafe
+ */
+export const unsafeWipe: <A>(self: Redacted<A>) => boolean = redacted_.unsafeWipe
+
+/**
+ * @category equivalence
+ * @since 3.3.0
+ */
+export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equivalence.Equivalence<Redacted<A>> =>
+  Equivalence.make((x, y) => x === y || (isEquivalent(value(x), value(y))))

package/src/STM.ts

@@ -1065,8 +1065,13 @@ export interface Adapter {
  * @since 2.0.0
  * @category constructors
  */
-export const gen: <Eff extends YieldWrap<STM<any, any, any>>, AEff>(
-  f: (resume: Adapter) => Generator<Eff, AEff, never>
+export const gen: <Self, Eff extends YieldWrap<STM<any, any, any>>, AEff>(
+  ...args:
+    | [
+      self: Self,
+      body: (this: Self, resume: Adapter) => Generator<Eff, AEff, never>
+    ]
+    | [body: (resume: Adapter) => Generator<Eff, AEff, never>]
 ) => STM<
   AEff,
   [Eff] extends [never] ? never : [Eff] extends [YieldWrap<STM<infer _A, infer E, infer _R>>] ? E : never,

package/src/Secret.ts

@@ -1,37 +1,44 @@
 /**
  * @since 2.0.0
+ * @deprecated
  */
 import type * as Equal from "./Equal.js"
 import * as InternalSecret from "./internal/secret.js"
+import type * as Redacted from "./Redacted.js"
 
 /**
  * @since 2.0.0
  * @category symbols
+ * @deprecated
  */
 export const SecretTypeId: unique symbol = InternalSecret.SecretTypeId
 
 /**
  * @since 2.0.0
  * @category symbols
+ * @deprecated
  */
 export type SecretTypeId = typeof SecretTypeId
 
 /**
  * @since 2.0.0
  * @category models
+ * @deprecated
  */
-export interface Secret extends Secret.Proto, Equal.Equal {
+export interface Secret extends Redacted.Redacted, Secret.Proto, Equal.Equal {
   /** @internal */
   readonly raw: Array<number>
 }
 
 /**
  * @since 2.0.0
+ * @deprecated
  */
 export declare namespace Secret {
   /**
    * @since 2.0.0
    * @category models
+   * @deprecated
    */
   export interface Proto {
     readonly [SecretTypeId]: SecretTypeId
@@ -41,35 +48,41 @@ export declare namespace Secret {
 /**
  * @since 2.0.0
  * @category refinements
+ * @deprecated
  */
 export const isSecret: (u: unknown) => u is Secret = InternalSecret.isSecret
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const make: (bytes: Array<number>) => Secret = InternalSecret.make
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const fromIterable: (iterable: Iterable<string>) => Secret = InternalSecret.fromIterable
 
 /**
  * @since 2.0.0
  * @category constructors
+ * @deprecated
  */
 export const fromString: (text: string) => Secret = InternalSecret.fromString
 
 /**
  * @since 2.0.0
  * @category getters
+ * @deprecated
  */
 export const value: (self: Secret) => string = InternalSecret.value
 
 /**
  * @since 2.0.0
  * @category unsafe
+ * @deprecated
  */
 export const unsafeWipe: (self: Secret) => void = InternalSecret.unsafeWipe

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/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"