effect 3.5.9 → 3.6.0

package/src/Effect.ts

@@ -4029,6 +4029,12 @@ export const tap: {
   ) => [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
     : [X] extends [PromiseLike<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
+  <A, X, E1, R1>(
+    f: (a: NoInfer<A>) => Effect<X, E1, R1>,
+    options: { onlyEffect: true }
+  ): <E, R>(
+    self: Effect<A, E, R>
+  ) => Effect<A, E | E1, R | R1>
   <X>(
     f: NotFunction<X>
   ): <A, E, R>(
@@ -4036,18 +4042,34 @@ export const tap: {
   ) => [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
     : [X] extends [PromiseLike<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
+  <X, E1, R1>(
+    f: Effect<X, E1, R1>,
+    options: { onlyEffect: true }
+  ): <A, E, R>(
+    self: Effect<A, E, R>
+  ) => Effect<A, E | E1, R | R1>
   <A, E, R, X>(
     self: Effect<A, E, R>,
     f: (a: NoInfer<A>) => X
   ): [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
     : [X] extends [PromiseLike<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
+  <A, E, R, X, E1, R1>(
+    self: Effect<A, E, R>,
+    f: (a: NoInfer<A>) => Effect<X, E1, R1>,
+    options: { onlyEffect: true }
+  ): Effect<A, E | E1, R | R1>
   <A, E, R, X>(
     self: Effect<A, E, R>,
     f: NotFunction<X>
   ): [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1>
     : [X] extends [PromiseLike<infer _A1>] ? Effect<A, E | Cause.UnknownException, R>
     : Effect<A, E, R>
+  <A, E, R, X, E1, R1>(
+    self: Effect<A, E, R>,
+    f: Effect<X, E1, R1>,
+    options: { onlyEffect: true }
+  ): Effect<A, E | E1, R | R1>
 } = core.tap
 
 /**

package/src/List.ts

@@ -29,6 +29,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual, identity, unsafeCoerce } from "./Function.js"
 import * as Hash from "./Hash.js"
 import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import type { nonEmpty, NonEmptyIterable } from "./NonEmptyIterable.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -72,7 +73,7 @@ export interface Nil<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspecta
  * @since 2.0.0
  * @category models
  */
-export interface Cons<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface Cons<out A> extends NonEmptyIterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
   readonly _tag: "Cons"
   readonly head: A
@@ -96,7 +97,7 @@ export const getEquivalence = <A>(isEquivalent: Equivalence.Equivalence<A>): Equ
 
 const _equivalence = getEquivalence(Equal.equals)
 
-const ConsProto: Omit<Cons<unknown>, "head" | "tail"> = {
+const ConsProto: Omit<Cons<unknown>, "head" | "tail" | typeof nonEmpty> = {
   [TypeId]: TypeId,
   _tag: "Cons",
   toString(this: Cons<unknown>) {

package/src/Metric.ts

@@ -361,7 +361,7 @@ export const set: {
  * @since 2.0.0
  * @category getters
  */
-export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped>> = internal.snapshot
+export const snapshot: Effect.Effect<Array<MetricPair.MetricPair.Untyped>> = internal.snapshot
 
 /**
  * Creates a metric that ignores input and produces constant output.

package/src/MetricRegistry.ts

@@ -25,7 +25,7 @@ export type MetricRegistryTypeId = typeof MetricRegistryTypeId
  */
 export interface MetricRegistry {
   readonly [MetricRegistryTypeId]: MetricRegistryTypeId
-  snapshot(): ReadonlyArray<MetricPair.MetricPair.Untyped>
+  snapshot(): Array<MetricPair.MetricPair.Untyped>
   get<Type extends MetricKeyType.MetricKeyType<any, any>>(
     key: MetricKey.MetricKey<Type>
   ): MetricHook.MetricHook<

package/src/Predicate.ts

@@ -29,6 +29,45 @@ export interface Refinement<in A, out B extends A> {
   (a: A): a is B
 }
 
+/**
+ * @since 3.6.0
+ * @category type-level
+ */
+export declare namespace Predicate {
+  /**
+   * @since 3.6.0
+   * @category type-level
+   */
+  export type In<T extends Any> = [T] extends [Predicate<infer _A>] ? _A : never
+  /**
+   * @since 3.6.0
+   * @category type-level
+   */
+  export type Any = Predicate<any>
+}
+
+/**
+ * @since 3.6.0
+ * @category type-level
+ */
+export declare namespace Refinement {
+  /**
+   * @since 3.6.0
+   * @category type-level
+   */
+  export type In<T extends Any> = [T] extends [Refinement<infer _A, infer _>] ? _A : never
+  /**
+   * @since 3.6.0
+   * @category type-level
+   */
+  export type Out<T extends Any> = [T] extends [Refinement<infer _, infer _B>] ? _B : never
+  /**
+   * @since 3.6.0
+   * @category type-level
+   */
+  export type Any = Refinement<any, any>
+}
+
 /**
  * Given a `Predicate<A>` returns a `Predicate<B>`
  *
@@ -686,23 +725,44 @@ export const productMany = <A>(
  * Similar to `Promise.all` but operates on `Predicate`s.
  *
  * ```
+ * [Refinement<A, B>, Refinement<C, D>, ...] -> Refinement<[A, C, ...], [B, D, ...]>
  * [Predicate<A>, Predicate<B>, ...] -> Predicate<[A, B, ...]>
+ * [Refinement<A, B>, Predicate<C>, ...] -> Refinement<[A, C, ...], [B, C, ...]>
  * ```
  *
  * @since 2.0.0
  */
-export const tuple = <T extends ReadonlyArray<Predicate<any>>>(
-  ...elements: T
-): Predicate<Readonly<{ [I in keyof T]: [T[I]] extends [Predicate<infer A>] ? A : never }>> => all(elements) as any
+export const tuple: {
+  <T extends ReadonlyArray<Predicate.Any>>(
+    ...elements: T
+  ): [Extract<T[number], Refinement.Any>] extends [never] ? Predicate<{ readonly [I in keyof T]: Predicate.In<T[I]> }>
+    : Refinement<
+      { readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.In<T[I]> : Predicate.In<T[I]> },
+      { readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.Out<T[I]> : Predicate.In<T[I]> }
+    >
+} = (...elements: ReadonlyArray<Predicate.Any>) => all(elements) as any
 
 /**
+ * ```
+ * { ab: Refinement<A, B>; cd: Refinement<C, D>, ... } -> Refinement<{ ab: A; cd: C; ... }, { ab: B; cd: D; ... }>
+ * { a: Predicate<A, B>; b: Predicate<B>, ... } -> Predicate<{ a: A; b: B; ... }>
+ * { ab: Refinement<A, B>; c: Predicate<C>, ... } -> Refinement<{ ab: A; c: C; ... }, { ab: B; c: С; ... }>
+ * ```
+ *
  * @since 2.0.0
  */
-export const struct = <R extends Record<string, Predicate<any>>>(
-  fields: R
-): Predicate<{ readonly [K in keyof R]: [R[K]] extends [Predicate<infer A>] ? A : never }> => {
+export const struct: {
+  <R extends Record<string, Predicate.Any>>(
+    fields: R
+  ): [Extract<R[keyof R], Refinement.Any>] extends [never] ?
+    Predicate<{ readonly [K in keyof R]: Predicate.In<R[K]> }> :
+    Refinement<
+      { readonly [K in keyof R]: R[K] extends Refinement.Any ? Refinement.In<R[K]> : Predicate.In<R[K]> },
+      { readonly [K in keyof R]: R[K] extends Refinement.Any ? Refinement.Out<R[K]> : Predicate.In<R[K]> }
+    >
+} = (<R extends Record<string, Predicate.Any>>(fields: R) => {
   const keys = Object.keys(fields)
-  return (a) => {
+  return (a: Record<string, unknown>) => {
     for (const key of keys) {
       if (!fields[key](a[key])) {
         return false
@@ -710,7 +770,7 @@ export const struct = <R extends Record<string, Predicate<any>>>(
     }
     return true
   }
-}
+}) as any
 
 /**
  * Negates the result of a given predicate.

package/src/Random.ts

@@ -1,11 +1,14 @@
 /**
  * @since 2.0.0
  */
+import type * as Array from "./Array.js"
+import type * as Cause from "./Cause.js"
 import type * as Chunk from "./Chunk.js"
 import type * as Context from "./Context.js"
 import type * as Effect from "./Effect.js"
 import * as defaultServices from "./internal/defaultServices.js"
 import * as internal from "./internal/random.js"
+import type * as NonEmptyIterable from "./NonEmptyIterable.js"
 
 /**
  * @since 2.0.0
@@ -103,6 +106,27 @@ export const nextIntBetween: (min: number, max: number) => Effect.Effect<number>
  */
 export const shuffle: <A>(elements: Iterable<A>) => Effect.Effect<Chunk.Chunk<A>> = defaultServices.shuffle
 
+/**
+ * Get a random element from an iterable.
+ *
+ * @example
+ * import { Effect, Random } from "effect"
+ *
+ * Effect.gen(function* () {
+ *   const randomItem = yield* Random.choice([1, 2, 3])
+ *   console.log(randomItem)
+ * })
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+export const choice: <Self extends Iterable<unknown>>(
+  elements: Self
+) => Self extends NonEmptyIterable.NonEmptyIterable<infer A> ? Effect.Effect<A>
+  : Self extends Array.NonEmptyReadonlyArray<infer A> ? Effect.Effect<A>
+  : Self extends Iterable<infer A> ? Effect.Effect<A, Cause.NoSuchElementException>
+  : never = defaultServices.choice
+
 /**
  * Retreives the `Random` service from the context and uses it to run the
  * specified workflow.

package/src/Stream.ts

@@ -373,6 +373,46 @@ export const asyncEffect: <A, E = never, R = never>(
   } | undefined
 ) => Stream<A, E, R> = internal.asyncEffect
 
+/**
+ * Creates a stream from an external push-based resource.
+ *
+ * You can use the `emit` helper to emit values to the stream. The `emit` helper
+ * returns a boolean indicating whether the value was emitted or not.
+ *
+ * You can also use the `emit` helper to signal the end of the stream by
+ * using apis such as `emit.end` or `emit.fail`.
+ *
+ * By default it uses an "unbounded" buffer size.
+ * You can customize the buffer size and strategy by passing an object as the
+ * second argument with the `bufferSize` and `strategy` fields.
+ *
+ * @example
+ * import { Effect, Stream } from "effect"
+ *
+ * Stream.asyncPush<string>((emit) =>
+ *   Effect.acquireRelease(
+ *     Effect.gen(function*() {
+ *       yield* Effect.log("subscribing")
+ *       return setInterval(() => emit.single("tick"), 1000)
+ *     }),
+ *     (handle) =>
+ *       Effect.gen(function*() {
+ *         yield* Effect.log("unsubscribing")
+ *         clearInterval(handle)
+ *       })
+ *   ), { bufferSize: 16, strategy: "dropping" })
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+export const asyncPush: <A, E = never, R = never>(
+  register: (emit: Emit.EmitOpsPush<E, A>) => Effect.Effect<unknown, never, R | Scope.Scope>,
+  options?: { readonly bufferSize: "unbounded" } | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | undefined
+  } | undefined
+) => Stream<A, E, Exclude<R, Scope.Scope>> = internal.asyncPush
+
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
  * times. The registration of the callback itself returns an a scoped
@@ -2887,6 +2927,38 @@ export const mkString: <E, R>(self: Stream<string, E, R>) => Effect.Effect<strin
  */
 export const never: Stream<never> = internal.never
 
+/**
+ * Adds an effect to be executed at the end of the stream.
+ *
+ * @example
+ * import { Console, Effect, Stream } from "effect"
+ *
+ * const stream = Stream.make(1, 2, 3).pipe(
+ *   Stream.map((n) => n * 2),
+ *   Stream.tap((n) => Console.log(`after mapping: ${n}`)),
+ *   Stream.onEnd(Console.log("Stream ended"))
+ * )
+ *
+ * Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+ * // after mapping: 2
+ * // after mapping: 4
+ * // after mapping: 6
+ * // Stream ended
+ * // { _id: 'Chunk', values: [ 2, 4, 6 ] }
+ *
+ * @since 3.6.0
+ * @category sequencing
+ */
+export const onEnd: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream<A, E | E2, R | R2>
+} = internal.onEnd
+
 /**
  * Runs the specified effect if this stream fails, providing the error to the
  * effect if it exists.
@@ -2918,6 +2990,38 @@ export const onDone: {
   <A, E, R, X, R2>(self: Stream<A, E, R>, cleanup: () => Effect.Effect<X, never, R2>): Stream<A, E, R | R2>
 } = internal.onDone
 
+/**
+ * Adds an effect to be executed at the start of the stream.
+ *
+ * @example
+ * import { Console, Effect, Stream } from "effect"
+ *
+ * const stream = Stream.make(1, 2, 3).pipe(
+ *   Stream.onStart(Console.log("Stream started")),
+ *   Stream.map((n) => n * 2),
+ *   Stream.tap((n) => Console.log(`after mapping: ${n}`))
+ * )
+ *
+ * // Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+ * // Stream started
+ * // after mapping: 2
+ * // after mapping: 4
+ * // after mapping: 6
+ * // { _id: 'Chunk', values: [ 2, 4, 6 ] }
+ *
+ * @since 3.6.0
+ * @category sequencing
+ */
+export const onStart: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream<A, E | E2, R | R2>
+} = internal.onStart
+
 /**
  * Translates any failure into a stream termination, making the stream
  * infallible and all failures unchecked.
@@ -5923,5 +6027,6 @@ export const fromEventListener: <A = unknown>(
     readonly capture?: boolean
     readonly passive?: boolean
     readonly once?: boolean
+    readonly bufferSize?: number | "unbounded" | undefined
   } | undefined
 ) => Stream<A> = internal.fromEventListener

package/src/StreamEmit.ts

@@ -81,3 +81,56 @@ export interface EmitOps<in R, in E, in A, out B> {
    */
   single(value: A): Promise<B>
 }
+
+/**
+ * @since 3.6.0
+ * @category models
+ */
+export interface EmitOpsPush<in E, in A> {
+  /**
+   * Emits a chunk containing the specified values.
+   */
+  chunk(chunk: Chunk.Chunk<A>): boolean
+
+  /**
+   * Emits a chunk containing the specified values.
+   */
+  array(chunk: ReadonlyArray<A>): boolean
+
+  /**
+   * Terminates with a cause that dies with the specified defect.
+   */
+  die<Err>(defect: Err): void
+
+  /**
+   * Terminates with a cause that dies with a `Throwable` with the specified
+   * message.
+   */
+  dieMessage(message: string): void
+
+  /**
+   * Either emits the specified value if this `Exit` is a `Success` or else
+   * terminates with the specified cause if this `Exit` is a `Failure`.
+   */
+  done(exit: Exit.Exit<A, E>): void
+
+  /**
+   * Terminates with an end of stream signal.
+   */
+  end(): void
+
+  /**
+   * Terminates with the specified error.
+   */
+  fail(error: E): void
+
+  /**
+   * Terminates the stream with the specified cause.
+   */
+  halt(cause: Cause.Cause<E>): void
+
+  /**
+   * Emits a chunk containing the specified value.
+   */
+  single(value: A): boolean
+}

package/src/Struct.ts

@@ -179,3 +179,25 @@ export const evolve: {
 export const get =
   <K extends PropertyKey>(key: K) => <S extends { [P in K]?: any }>(s: S): MatchRecord<S, S[K] | undefined, S[K]> =>
     s[key]
+
+/**
+ * Retrieves the object keys that are strings in a typed manner
+ *
+ * @example
+ * import { Struct } from "effect"
+ *
+ * const symbol: unique symbol = Symbol()
+ *
+ * const value = {
+ *   a: 1,
+ *   b: 2,
+ *   [symbol]: 3
+ * }
+ *
+ * const keys: Array<"a" | "b"> = Struct.keys(value)
+ *
+ * assert.deepStrictEqual(keys, ["a", "b"])
+ *
+ * @since 3.6.0
+ */
+export const keys = <T extends {}>(o: T): Array<(keyof T) & string> => Object.keys(o) as Array<(keyof T) & string>

package/src/index.ts

@@ -187,6 +187,11 @@ export * as Cron from "./Cron.js"
  */
 export * as Data from "./Data.js"
 
+/**
+ * @since 3.6.0
+ */
+export * as DateTime from "./DateTime.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/configProvider.ts

@@ -68,7 +68,7 @@ export const makeFlat = (
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split: boolean
-    ) => Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+    ) => Effect.Effect<Array<A>, ConfigError.ConfigError>
     readonly enumerateChildren: (
       path: ReadonlyArray<string>
     ) => Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError>
@@ -114,7 +114,7 @@ export const fromEnv = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const current = getEnv()
     const valueOpt = pathString in current ? Option.some(current[pathString]!) : Option.none()
@@ -165,7 +165,7 @@ export const fromMap = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const valueOpt = mapWithIndexSplit.has(pathString) ?
       Option.some(mapWithIndexSplit.get(pathString)!) :
@@ -240,20 +240,20 @@ const fromFlatLoop = <A>(
   prefix: ReadonlyArray<string>,
   config: Config.Config<A>,
   split: boolean
-): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(Arr.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Arr.of(op.value)) as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
         () => fromFlatLoop(flat, prefix, op.config, split)
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_FAIL: {
       return core.fail(configError.MissingData(prefix, op.message)) as Effect.Effect<
-        ReadonlyArray<A>,
+        Array<A>,
         ConfigError.ConfigError
       >
     }
@@ -269,11 +269,11 @@ const fromFlatLoop = <A>(
           }
           return core.fail(error1)
         })
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_LAZY: {
       return core.suspend(() => fromFlatLoop(flat, prefix, op.config(), split)) as Effect.Effect<
-        ReadonlyArray<A>,
+        Array<A>,
         ConfigError.ConfigError
       >
     }
@@ -290,7 +290,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_NESTED: {
       return core.suspend(() =>
@@ -300,7 +300,7 @@ const fromFlatLoop = <A>(
           op.config,
           split
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_PRIMITIVE: {
       return pipe(
@@ -317,7 +317,7 @@ const fromFlatLoop = <A>(
             })
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_SEQUENCE: {
       return pipe(
@@ -330,7 +330,7 @@ const fromFlatLoop = <A>(
               if (indices.length === 0) {
                 return core.suspend(() =>
                   core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Arr.of)
-                ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+                ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
@@ -344,7 +344,7 @@ const fromFlatLoop = <A>(
                   }
                   return Arr.of(flattened)
                 })
-              ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+              ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
             })
           )
         )
@@ -382,7 +382,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_ZIP_WITH: {
       return core.suspend(() =>
@@ -430,7 +430,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
   }
 }
@@ -592,7 +592,7 @@ export const within = dual<
   return orElse(nest, () => self)
 })
 
-const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
+const splitPathString = (text: string, delim: string): Array<string> => {
   const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
@@ -603,7 +603,7 @@ const parsePrimitive = <A>(
   primitive: Config.Config.Primitive<A>,
   delimiter: string,
   split: boolean
-): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
   if (!split) {
     return pipe(
       primitive.parse(text),
@@ -620,11 +620,11 @@ const parsePrimitive = <A>(
   )
 }
 
-const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<ReadonlyArray<A>> => {
+const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): Array<Array<A>> => {
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
+const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Array<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({