effect 2.0.0-next.55 → 2.0.0-next.57

package/src/Chunk.ts

@@ -7,7 +7,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual, identity, pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { TypeLambda } from "./HKT.js"
-import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { NonEmptyIterable } from "./NonEmptyIterable.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
@@ -17,6 +17,7 @@ import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
 import * as RA from "./ReadonlyArray.js"
 import type { NonEmptyReadonlyArray } from "./ReadonlyArray.js"
+import type * as Types from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/Chunk") as TypeId
 
@@ -30,9 +31,9 @@ export type TypeId = typeof TypeId
  * @category models
  * @since 2.0.0
  */
-export interface Chunk<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface Chunk<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: Types.Covariant<A>
   }
   readonly length: number
   /** @internal */
@@ -49,7 +50,7 @@ export interface Chunk<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectabl
  * @category model
  * @since 2.0.0
  */
-export interface NonEmptyChunk<A> extends Chunk<A>, NonEmptyIterable<A> {}
+export interface NonEmptyChunk<out A> extends Chunk<A>, NonEmptyIterable<A> {}
 
 /**
  * @category type lambdas
@@ -126,7 +127,7 @@ const ChunkProto: Omit<Chunk<unknown>, "backing" | "depth" | "left" | "length" |
     _A: (_: never) => _
   },
   toString<A>(this: Chunk<A>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON<A>(this: Chunk<A>) {
     return {
@@ -413,7 +414,7 @@ export const unsafeGet: {
 export const append: {
   <A2>(a: A2): <A>(self: Chunk<A>) => NonEmptyChunk<A2 | A>
   <A, A2>(self: Chunk<A>, a: A2): NonEmptyChunk<A | A2>
-} = dual(2, <A, A2>(self: Chunk<A>, a: A2): NonEmptyChunk<A | A2> => appendAllNonEmpty(self, of(a)))
+} = dual(2, <A, A2>(self: Chunk<A>, a: A2): NonEmptyChunk<A | A2> => appendAll(self, of(a)))
 
 /**
  * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
@@ -424,7 +425,7 @@ export const append: {
 export const prepend: {
   <B>(elem: B): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>
   <A, B>(self: Chunk<A>, elem: B): NonEmptyChunk<A | B>
-} = dual(2, <A, B>(self: Chunk<A>, elem: B): NonEmptyChunk<A | B> => appendAllNonEmpty(of(elem), self))
+} = dual(2, <A, B>(self: Chunk<A>, elem: B): NonEmptyChunk<A | B> => appendAll(of(elem), self))
 
 /**
  * Takes the first up to `n` elements from the chunk
@@ -533,46 +534,59 @@ export const dropRight: {
  * @since 2.0.0
  */
 export const dropWhile: {
-  <A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>
-  <A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A> => {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> => {
   const arr = toReadonlyArray(self)
   const len = arr.length
   let i = 0
-  while (i < len && f(arr[i]!)) {
+  while (i < len && predicate(arr[i]!)) {
     i++
   }
   return drop(self, i)
 })
 
 /**
+ * Prepends the specified prefix chunk to the beginning of the specified chunk.
+ * If either chunk is non-empty, the result is also a non-empty chunk.
+ *
+ * @example
+ * import * as Chunk from "effect/Chunk"
+ *
+ * assert.deepStrictEqual(
+ *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
+ *   ["a", "b", 1, 2]
+ * )
+ *
  * @category concatenating
  * @since 2.0.0
  */
 export const prependAll: {
-  <B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>
-  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
-} = dual(2, <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): Chunk<A | B> => appendAll(that, self))
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export const prependAllNonEmpty: {
-  <B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>
-  <B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<B | A>
+  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.With2<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
   <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
-} = dual(2, <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B> => prependAll(self, that) as any)
+  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
+} = dual(2, <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): Chunk<A | B> => appendAll(that, self))
 
 /**
- * Concatenates the two chunks
+ * Concatenates two chunks, combining their elements.
+ * If either chunk is non-empty, the result is also a non-empty chunk.
+ *
+ * @example
+ * import * as Chunk from "effect/Chunk"
+ *
+ * assert.deepStrictEqual(
+ *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
+ *   [1, 2, "a", "b"]
+ * )
  *
  * @category concatenating
  * @since 2.0.0
  */
 export const appendAll: {
-  <B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>
+  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.With2<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
+  <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
+  <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
 } = dual(2, <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B> => {
   if (self.backing._tag === "IEmpty") {
@@ -615,17 +629,6 @@ export const appendAll: {
   }
 })
 
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export const appendAllNonEmpty: {
-  <B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>
-  <B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<B | A>
-  <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
-  <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
-} = dual(2, <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B> => appendAll(self, that) as any)
-
 /**
  * Returns a filtered and mapped subset of the elements.
  *
@@ -647,13 +650,13 @@ export const filterMap: {
  * @category filtering
  */
 export const filter: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Chunk<B>
   <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
-  <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): Chunk<B>
+  <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>) =>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> =>
     unsafeFromArray(RA.filterMap(self, O.liftPredicate(predicate)))
 )
 
@@ -677,13 +680,16 @@ export const filterMapWhile: {
 export const compact = <A>(self: Chunk<Option<A>>): Chunk<A> => filterMap(self, identity)
 
 /**
- * Returns a chunk with the elements mapped by the specified function.
+ * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
  *
  * @since 2.0.0
  * @category sequencing
  */
 export const flatMap: {
-  <A, B>(f: (a: A, i: number) => Chunk<B>): (self: Chunk<A>) => Chunk<B>
+  <S extends Chunk<any>, T extends Chunk<any>>(
+    f: (a: Chunk.Infer<S>, i: number) => T
+  ): (self: S) => Chunk.With2<S, T, Chunk.Infer<T>>
+  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => NonEmptyChunk<B>): NonEmptyChunk<B>
   <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>): Chunk<B>
 } = dual(2, <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>) => {
   if (self.backing._tag === "ISingleton") {
@@ -697,15 +703,6 @@ export const flatMap: {
   return out
 })
 
-/**
- * @category sequencing
- * @since 2.0.0
- */
-export const flatMapNonEmpty: {
-  <A, B>(f: (a: A, i: number) => NonEmptyChunk<B>): (self: NonEmptyChunk<A>) => NonEmptyChunk<B>
-  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => NonEmptyChunk<B>): NonEmptyChunk<B>
-} = flatMap as any
-
 /**
  * Applies the specified function to each element of the `List`.
  *
@@ -723,15 +720,10 @@ export const forEach: {
  * @since 2.0.0
  * @category sequencing
  */
-export const flatten: <A>(self: Chunk<Chunk<A>>) => Chunk<A> = flatMap(identity)
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-export const flattenNonEmpty: <A>(
-  self: NonEmptyChunk<NonEmptyChunk<A>>
-) => NonEmptyChunk<A> = flatMapNonEmpty(identity)
+export const flatten: {
+  <A>(self: NonEmptyChunk<NonEmptyChunk<A>>): NonEmptyChunk<A>
+  <A>(self: Chunk<Chunk<A>>): Chunk<A>
+} = flatMap(identity) as any
 
 /**
  * Groups elements in chunks of up to `n` elements.
@@ -838,23 +830,40 @@ export declare namespace Chunk {
   /**
    * @since 2.0.0
    */
-  export type Infer<T extends Chunk<any>> = T extends Chunk<infer A> ? A : never
+  export type Infer<S extends Chunk<any>> = S extends Chunk<infer A> ? A : never
+
+  /**
+   * @since 2.0.0
+   */
+  export type With<S extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>
 
   /**
    * @since 2.0.0
    */
-  export type With<T extends Chunk<any>, A> = T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>
+  export type With2<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A>
+    : T extends NonEmptyChunk<any> ? NonEmptyChunk<A>
+    : Chunk<A>
 }
 
 /**
- * Returns a chunk with the elements mapped by the specified f function.
+ * Transforms the elements of a chunk using the specified mapping function.
+ * If the input chunk is non-empty, the resulting chunk will also be non-empty.
+ *
+ * @example
+ * import * as Chunk from "effect/Chunk"
+ *
+ * assert.deepStrictEqual(
+ *   Chunk.map(Chunk.make(1, 2), (n) => n + 1),
+ *   Chunk.make(2, 3)
+ * )
  *
  * @since 2.0.0
  * @category mapping
  */
 export const map: {
-  <T extends Chunk<any>, B>(f: (a: Chunk.Infer<T>, i: number) => B): (self: T) => Chunk.With<T, B>
-  <T extends Chunk<any>, B>(self: T, f: (a: Chunk.Infer<T>, i: number) => B): Chunk.With<T, B>
+  <S extends Chunk<any>, B>(f: (a: Chunk.Infer<S>, i: number) => B): (self: S) => Chunk.With<S, B>
+  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>
+  <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>
 } = dual(2, <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B> =>
   self.backing._tag === "ISingleton" ?
     of(f(self.backing.a, 0)) :
@@ -881,13 +890,20 @@ export const mapAccum: {
  * @since 2.0.0
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => [Chunk<Exclude<C, B>>, Chunk<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: Chunk<B>) => [Chunk<B>, Chunk<B>]
-  <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): [Chunk<Exclude<C, B>>, Chunk<B>]
-  <B extends A, A = B>(self: Chunk<B>, predicate: (a: A) => boolean): [Chunk<B>, Chunk<B>]
+  <C extends A, B extends A, A = C>(
+    refinement: (a: A, i: number) => a is B
+  ): (self: Chunk<C>) => [excluded: Chunk<Exclude<C, B>>, satisfying: Chunk<B>]
+  <B extends A, A = B>(
+    predicate: (a: A, i: number) => boolean
+  ): (self: Chunk<B>) => [excluded: Chunk<B>, satisfying: Chunk<B>]
+  <A, B extends A>(
+    self: Chunk<A>,
+    refinement: (a: A, i: number) => a is B
+  ): [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>]
+  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>]
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: (a: A) => boolean): [Chunk<B>, Chunk<B>] =>
+  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>] =>
     pipe(
       RA.partition(toReadonlyArray(self), predicate),
       ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]
@@ -901,9 +917,9 @@ export const partition: {
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => [Chunk<B>, Chunk<C>]
-  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [Chunk<B>, Chunk<C>]
-} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [Chunk<B>, Chunk<C>] =>
+  <A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>]
+  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>]
+} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>] =>
   pipe(
     RA.partitionMap(toReadonlyArray(self), f),
     ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]
@@ -962,8 +978,8 @@ export const sortWith: {
  * @category elements
  */
 export const splitAt: {
-  (n: number): <A>(self: Chunk<A>) => [Chunk<A>, Chunk<A>]
-  <A>(self: Chunk<A>, n: number): [Chunk<A>, Chunk<A>]
+  (n: number): <A>(self: Chunk<A>) => [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
+  <A>(self: Chunk<A>, n: number): [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
 } = dual(2, <A>(self: Chunk<A>, n: number): [Chunk<A>, Chunk<A>] => [take(self, n), drop(self, n)])
 
 /**
@@ -984,9 +1000,9 @@ export const split: {
  * @since 2.0.0
  */
 export const splitWhere: {
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => [Chunk<A>, Chunk<A>]
-  <A>(self: Chunk<A>, predicate: Predicate<A>): [Chunk<A>, Chunk<A>]
-} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): [Chunk<A>, Chunk<A>] => {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => [beforeMatch: Chunk<B>, fromMatch: Chunk<B>]
+  <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>]
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>] => {
   let i = 0
   for (const a of toReadonlyArray(self)) {
     if (predicate(a)) {
@@ -1032,18 +1048,20 @@ export const takeRight: {
  * @category elements
  */
 export const takeWhile: {
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => Chunk<A>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Chunk<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
+  <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>
   <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>) => {
-  const res: Array<A> = []
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> => {
+  const out: Array<A> = []
   for (const a of toReadonlyArray(self)) {
     if (predicate(a)) {
-      res.push(a)
+      out.push(a)
     } else {
       break
     }
   }
-  return unsafeFromArray(res)
+  return unsafeFromArray(out)
 })
 
 /**
@@ -1093,7 +1111,7 @@ export const unzip = <A, B>(self: Chunk<readonly [A, B]>): [Chunk<A>, Chunk<B>]
  * Zips this chunk pointwise with the specified chunk using the specified combiner.
  *
  * @since 2.0.0
- * @category elements
+ * @category zipping
  */
 export const zipWith: {
   <A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>
@@ -1108,7 +1126,7 @@ export const zipWith: {
  * Zips this chunk pointwise with the specified chunk.
  *
  * @since 2.0.0
- * @category elements
+ * @category zipping
  */
 export const zip: {
   <B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<[A, B]>
@@ -1236,9 +1254,9 @@ export const containsWith: <A>(
  */
 export const findFirst: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Option<B>
   <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Chunk<B>, predicate: Predicate<A>): Option<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
 } = RA.findFirst
 
 /**
@@ -1260,9 +1278,9 @@ export const findFirstIndex: {
  */
 export const findLast: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Option<B>
   <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Chunk<B>, predicate: Predicate<A>): Option<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
 } = RA.findLast
 
 /**
@@ -1300,12 +1318,11 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => self is NonEmptyChunk<B>
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): self is NonEmptyChunk<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => self is NonEmptyChunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): self is NonEmptyChunk<B> =>
-    RA.fromIterable(self).some(predicate)
+  <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A> => RA.fromIterable(self).some(predicate)
 )
 
 /**

package/src/Clock.ts

@@ -31,7 +31,7 @@ export interface Clock {
   /**
    * Unsafely returns the current time in milliseconds.
    */
-  readonly unsafeCurrentTimeMillis: () => number
+  unsafeCurrentTimeMillis(): number
   /**
    * Returns the current time in milliseconds.
    */
@@ -39,7 +39,7 @@ export interface Clock {
   /**
    * Unsafely returns the current time in nanoseconds.
    */
-  readonly unsafeCurrentTimeNanos: () => bigint
+  unsafeCurrentTimeNanos(): bigint
   /**
    * Returns the current time in nanoseconds.
    */
@@ -47,7 +47,7 @@ export interface Clock {
   /**
    * Asynchronously sleeps for the specified duration.
    */
-  readonly sleep: (duration: Duration.Duration) => Effect.Effect<never, never, void>
+  sleep(duration: Duration.Duration): Effect.Effect<never, never, void>
 }
 
 /**
@@ -70,7 +70,7 @@ export interface ClockScheduler {
   /**
    * Unsafely schedules the specified task for the specified duration.
    */
-  readonly unsafeSchedule: (task: Task, duration: Duration.Duration) => CancelToken
+  unsafeSchedule(task: Task, duration: Duration.Duration): CancelToken
 }
 
 /**

package/src/Config.ts

@@ -13,6 +13,7 @@ import type * as LogLevel from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -32,7 +33,7 @@ export type ConfigTypeId = typeof ConfigTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Config<A> extends Config.Variance<A>, Pipeable {}
+export interface Config<out A> extends Config.Variance<A>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -42,9 +43,9 @@ export declare namespace Config {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<out A> {
     readonly [ConfigTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -52,9 +53,9 @@ export declare namespace Config {
    * @since 2.0.0
    * @category models
    */
-  export interface Primitive<A> extends Config<A> {
+  export interface Primitive<out A> extends Config<A> {
     readonly description: string
-    readonly parse: (text: string) => Either.Either<ConfigError.ConfigError, A>
+    parse(text: string): Either.Either<ConfigError.ConfigError, A>
   }
 
   /**
@@ -100,7 +101,7 @@ export const all: <const Arg extends Iterable<Config<any>> | Record<string, Conf
  * @since 2.0.0
  * @category constructors
  */
-export const array: <A>(config: Config<A>, name?: string | undefined) => Config<ReadonlyArray<A>> = internal.array
+export const array: <A>(config: Config<A>, name?: string) => Config<ReadonlyArray<A>> = internal.array
 
 /**
  * Constructs a config for a boolean value.
@@ -108,7 +109,7 @@ export const array: <A>(config: Config<A>, name?: string | undefined) => Config<
  * @since 2.0.0
  * @category constructors
  */
-export const boolean: (name?: string | undefined) => Config<boolean> = internal.boolean
+export const boolean: (name?: string) => Config<boolean> = internal.boolean
 
 /**
  * Constructs a config for a sequence of values.
@@ -116,7 +117,7 @@ export const boolean: (name?: string | undefined) => Config<boolean> = internal.
  * @since 2.0.0
  * @category constructors
  */
-export const chunk: <A>(config: Config<A>, name?: string | undefined) => Config<Chunk.Chunk<A>> = internal.chunk
+export const chunk: <A>(config: Config<A>, name?: string) => Config<Chunk.Chunk<A>> = internal.chunk
 
 /**
  * Constructs a config for a date value.
@@ -124,7 +125,7 @@ export const chunk: <A>(config: Config<A>, name?: string | undefined) => Config<
  * @since 2.0.0
  * @category constructors
  */
-export const date: (name?: string | undefined) => Config<Date> = internal.date
+export const date: (name?: string) => Config<Date> = internal.date
 
 /**
  * Constructs a config that fails with the specified message.
@@ -140,7 +141,7 @@ export const fail: (message: string) => Config<never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const number: (name?: string | undefined) => Config<number> = internal.number
+export const number: (name?: string) => Config<number> = internal.number
 
 /**
  * Constructs a config for a integer value.
@@ -148,7 +149,7 @@ export const number: (name?: string | undefined) => Config<number> = internal.nu
  * @since 2.0.0
  * @category constructors
  */
-export const integer: (name?: string | undefined) => Config<number> = internal.integer
+export const integer: (name?: string) => Config<number> = internal.integer
 
 /**
  * Constructs a config for a `LogLevel` value.
@@ -156,7 +157,7 @@ export const integer: (name?: string | undefined) => Config<number> = internal.i
  * @since 2.0.0
  * @category constructors
  */
-export const logLevel: (name?: string | undefined) => Config<LogLevel.LogLevel> = internal.logLevel
+export const logLevel: (name?: string) => Config<LogLevel.LogLevel> = internal.logLevel
 
 /**
  * This function returns `true` if the specified value is an `Config` value,
@@ -182,7 +183,7 @@ export const isConfig: (u: unknown) => u is Config<unknown> = internal.isConfig
  * a different value, constructed using the specified function.
  *
  * @since 2.0.0
- * @category utils
+ * @category mapping
  */
 export const map: {
   <A, B>(f: (a: A) => B): (self: Config<A>) => Config<B>
@@ -299,7 +300,7 @@ export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
  * @since 2.0.0
  * @category constructors
  */
-export const secret: (name?: string | undefined) => Config<ConfigSecret.ConfigSecret> = internal.secret
+export const secret: (name?: string) => Config<ConfigSecret.ConfigSecret> = internal.secret
 
 /**
  * Constructs a config for a sequence of values.
@@ -307,7 +308,7 @@ export const secret: (name?: string | undefined) => Config<ConfigSecret.ConfigSe
  * @since 2.0.0
  * @category constructors
  */
-export const hashSet: <A>(config: Config<A>, name?: string | undefined) => Config<HashSet.HashSet<A>> = internal.hashSet
+export const hashSet: <A>(config: Config<A>, name?: string) => Config<HashSet.HashSet<A>> = internal.hashSet
 
 /**
  * Constructs a config for a string value.
@@ -315,7 +316,7 @@ export const hashSet: <A>(config: Config<A>, name?: string | undefined) => Confi
  * @since 2.0.0
  * @category constructors
  */
-export const string: (name?: string | undefined) => Config<string> = internal.string
+export const string: (name?: string) => Config<string> = internal.string
 
 /**
  * Constructs a config which contains the specified value.
@@ -347,8 +348,7 @@ export const sync: <A>(value: LazyArg<A>) => Config<A> = internal.sync
  * @since 2.0.0
  * @category constructors
  */
-export const hashMap: <A>(config: Config<A>, name?: string | undefined) => Config<HashMap.HashMap<string, A>> =
-  internal.hashMap
+export const hashMap: <A>(config: Config<A>, name?: string) => Config<HashMap.HashMap<string, A>> = internal.hashMap
 
 /**
  * Constructs a config from some configuration wrapped with the `Wrap<A>` utility type.
@@ -427,7 +427,7 @@ export const withDescription: {
  * config.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const zip: {
   <B>(that: Config<B>): <A>(self: Config<A>) => Config<[A, B]>
@@ -439,7 +439,7 @@ export const zip: {
  * using the provided function.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const zipWith: {
   <B, A, C>(that: Config<B>, f: (a: A, b: B) => C): (self: Config<A>) => Config<C>

package/src/ConfigError.ts

@@ -53,18 +53,18 @@ export declare namespace ConfigError {
  * @since 2.0.0
  * @category models
  */
-export interface ConfigErrorReducer<C, Z> {
-  readonly andCase: (context: C, left: Z, right: Z) => Z
-  readonly orCase: (context: C, left: Z, right: Z) => Z
-  readonly invalidDataCase: (context: C, path: Array<string>, message: string) => Z
-  readonly missingDataCase: (context: C, path: Array<string>, message: string) => Z
-  readonly sourceUnavailableCase: (
+export interface ConfigErrorReducer<in C, in out Z> {
+  andCase(context: C, left: Z, right: Z): Z
+  orCase(context: C, left: Z, right: Z): Z
+  invalidDataCase(context: C, path: Array<string>, message: string): Z
+  missingDataCase(context: C, path: Array<string>, message: string): Z
+  sourceUnavailableCase(
     context: C,
     path: Array<string>,
     message: string,
     cause: Cause.Cause<unknown>
-  ) => Z
-  readonly unsupportedCase: (context: C, path: Array<string>, message: string) => Z
+  ): Z
+  unsupportedCase(context: C, path: Array<string>, message: string): Z
 }
 
 /**