effect 2.0.0-next.57 → 2.0.0-next.59

package/src/ReadonlyArray.ts

@@ -15,6 +15,7 @@ import * as readonlyArray from "./internal/readonlyArray.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
 import * as Order from "./Order.js"
+import { not } from "./Predicate.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import * as RR from "./ReadonlyRecord.js"
 import * as Tuple from "./Tuple.js"
@@ -104,7 +105,9 @@ export const replicate: {
 } = dual(2, <A>(a: A, n: number): NonEmptyArray<A> => makeBy(n, () => a))
 
 /**
- * @category conversions
+ * Creates a new `Array` from an iterable collection of values.
+ *
+ * @category constructors
  * @since 2.0.0
  */
 export const fromIterable = <A>(collection: Iterable<A>): Array<A> =>
@@ -242,7 +245,7 @@ export const prepend: {
 export const prependAll: {
   <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
     that: T
-  ): (self: S) => ReadonlyArray.With2<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
+  ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: Iterable<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<A | B>
   <A, B>(self: NonEmptyReadonlyArray<A>, that: Iterable<B>): NonEmptyArray<A | B>
   <A, B>(self: Iterable<A>, that: Iterable<B>): Array<A | B>
@@ -272,7 +275,7 @@ export const append: {
 export const appendAll: {
   <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
     that: T
-  ): (self: S) => ReadonlyArray.With2<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
+  ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: Iterable<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<A | B>
   <A, B>(self: NonEmptyReadonlyArray<A>, that: Iterable<B>): NonEmptyArray<A | B>
   <A, B>(self: Iterable<A>, that: Iterable<B>): Array<A | B>
@@ -434,7 +437,7 @@ export const unsafeGet: {
 /**
  * Return a tuple containing the first element, and a new `Array` of the remaining elements, if any.
  *
- * @category getters
+ * @category splitting
  * @since 2.0.0
  */
 export const unprepend = <A>(
@@ -444,7 +447,7 @@ export const unprepend = <A>(
 /**
  * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
  *
- * @category getters
+ * @category splitting
  * @since 2.0.0
  */
 export const unappend = <A>(
@@ -588,7 +591,7 @@ const spanIndex = <A>(self: Iterable<A>, predicate: Predicate<A>): number => {
  * 1. the longest initial subarray for which all elements satisfy the specified predicate
  * 2. the remaining elements
  *
- * @category filtering
+ * @category splitting
  * @since 2.0.0
  */
 export const span: {
@@ -832,10 +835,10 @@ export const remove: {
  * @category elements
  * @since 2.0.0
  */
-export const reverse: {
-  <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>
-  <A>(self: Iterable<A>): Array<A>
-} = (<A>(self: Iterable<A>): Array<A> => Array.from(self).reverse()) as any
+export const reverse = <S extends Iterable<any> | NonEmptyReadonlyArray<any>>(
+  self: S
+): S extends NonEmptyReadonlyArray<infer A> ? NonEmptyArray<A> : S extends Iterable<infer A> ? Array<A> : never =>
+  Array.from(self).reverse() as any
 
 /**
  * Create a new array with elements sorted in increasing order based on the specified comparator.
@@ -847,7 +850,7 @@ export const reverse: {
 export const sort: {
   <B>(
     O: Order.Order<B>
-  ): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>
+  ): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A extends B, B>(self: NonEmptyReadonlyArray<A>, O: Order.Order<B>): NonEmptyArray<A>
   <A extends B, B>(self: Iterable<A>, O: Order.Order<B>): Array<A>
 } = dual(2, <A extends B, B>(self: Iterable<A>, O: Order.Order<B>): Array<A> => {
@@ -876,18 +879,19 @@ export const sortWith: {
  * @category sorting
  * @since 2.0.0
  */
-export const sortBy = <B>(...orders: ReadonlyArray<Order.Order<B>>): {
-  <A extends B>(as: NonEmptyReadonlyArray<A>): NonEmptyArray<A>
-  <A extends B>(self: Iterable<A>): Array<A>
-} => {
+export const sortBy = <S extends Iterable<any> | NonEmptyReadonlyArray<any>>(
+  ...orders: ReadonlyArray<Order.Order<ReadonlyArray.Infer<S>>>
+) => {
   const sortByAll = sort(Order.combineAll(orders))
-  return (<A extends B>(self: Iterable<A>): Array<A> => {
+  return (
+    self: S
+  ): S extends NonEmptyReadonlyArray<infer A> ? NonEmptyArray<A> : S extends Iterable<infer A> ? Array<A> : never => {
     const input = fromIterable(self)
     if (isNonEmptyReadonlyArray(input)) {
-      return sortByAll(input)
+      return sortByAll(input) as any
     }
-    return []
-  }) as any
+    return [] as any
+  }
 }
 
 /**
@@ -939,22 +943,23 @@ export const zipWith: {
  *
  * @since 2.0.0
  */
-export const unzip: {
-  <A, B>(self: NonEmptyReadonlyArray<readonly [A, B]>): [NonEmptyArray<A>, NonEmptyArray<B>]
-  <A, B>(self: Iterable<readonly [A, B]>): [Array<A>, Array<B>]
-} = (<A, B>(self: Iterable<readonly [A, B]>): [Array<A>, Array<B>] => {
-  const input = fromIterable(self)
-  if (isNonEmptyReadonlyArray(input)) {
-    const fa: NonEmptyArray<A> = [input[0][0]]
-    const fb: NonEmptyArray<B> = [input[0][1]]
-    for (let i = 1; i < input.length; i++) {
-      fa[i] = input[i][0]
-      fb[i] = input[i][1]
+export const unzip: <S extends Iterable<readonly [any, any]> | NonEmptyReadonlyArray<readonly [any, any]>>(
+  self: S
+) => S extends NonEmptyReadonlyArray<readonly [infer A, infer B]> ? [NonEmptyArray<A>, NonEmptyArray<B>]
+  : S extends Iterable<readonly [infer A, infer B]> ? [Array<A>, Array<B>]
+  : never = (<A, B>(self: Iterable<readonly [A, B]>): [Array<A>, Array<B>] => {
+    const input = fromIterable(self)
+    if (isNonEmptyReadonlyArray(input)) {
+      const fa: NonEmptyArray<A> = [input[0][0]]
+      const fb: NonEmptyArray<B> = [input[0][1]]
+      for (let i = 1; i < input.length; i++) {
+        fa[i] = input[i][0]
+        fb[i] = input[i][1]
+      }
+      return [fa, fb]
     }
-    return [fa, fb]
-  }
-  return [[], []]
-}) as any
+    return [[], []]
+  }) as any
 
 /**
  * Places an element in between members of an `Iterable`.
@@ -965,7 +970,7 @@ export const unzip: {
 export const intersperse: {
   <B>(
     middle: B
-  ): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>
+  ): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A, B>(self: NonEmptyReadonlyArray<A>, middle: B): NonEmptyArray<A | B>
   <A, B>(self: Iterable<A>, middle: B): Array<A | B>
 } = dual(2, <A, B>(self: Iterable<A>, middle: B): Array<A | B> => {
@@ -1047,7 +1052,7 @@ export const setNonEmptyLast: {
  * @since 2.0.0
  */
 export const rotate: {
-  (n: number): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>
+  (n: number): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<A>
   <A>(self: Iterable<A>, n: number): Array<A>
 } = dual(2, <A>(self: Iterable<A>, n: number): Array<A> => {
@@ -1108,9 +1113,9 @@ export const contains: {
  * @since 2.0.0
  */
 export const chop: {
-  <A, B>(
-    f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]
-  ): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>
+  <S extends ReadonlyArray<any> | Iterable<any>, B>(
+    f: (as: NonEmptyReadonlyArray<ReadonlyArray.Infer<S>>) => readonly [B, ReadonlyArray<ReadonlyArray.Infer<S>>]
+  ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A, B>(
     self: NonEmptyReadonlyArray<A>,
     f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]
@@ -1142,7 +1147,7 @@ export const chop: {
  * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements.
  * The value of `n` can be `0`.
  *
- * @category getters
+ * @category splitting
  * @since 2.0.0
  */
 export const splitAt: {
@@ -1160,19 +1165,11 @@ export const splitAt: {
   return [input, []]
 })
 
-/**
- * @since 2.0.0
- */
-export const copy: {
-  <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>
-  <A>(self: ReadonlyArray<A>): Array<A>
-} = (<A>(self: ReadonlyArray<A>): Array<A> => self.slice()) as any
-
 /**
  * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements.
  * The value of `n` must be `>= 1`.
  *
- * @category getters
+ * @category splitting
  * @since 2.0.0
  */
 export const splitNonEmptyAt: {
@@ -1185,6 +1182,44 @@ export const splitNonEmptyAt: {
     [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)]
 })
 
+/**
+ * Splits this iterable into `n` equally sized arrays.
+ *
+ * @since 2.0.0
+ * @category splitting
+ */
+export const split: {
+  (n: number): <A>(self: Iterable<A>) => Array<Array<A>>
+  <A>(self: Iterable<A>, n: number): Array<Array<A>>
+} = dual(2, <A>(self: Iterable<A>, n: number) => {
+  const input = fromIterable(self)
+  return chunksOf(input, Math.ceil(input.length / Math.floor(n)))
+})
+
+/**
+ * Splits this iterable on the first element that matches this predicate.
+ * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward.
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const splitWhere: {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => [beforeMatch: Array<B>, fromMatch: Array<B>]
+  <A>(self: Iterable<A>, predicate: Predicate<A>): [beforeMatch: Array<A>, fromMatch: Array<A>]
+} = dual(
+  2,
+  <A>(self: Iterable<A>, predicate: Predicate<A>): [beforeMatch: Array<A>, fromMatch: Array<A>] =>
+    span(self, not(predicate))
+)
+
+/**
+ * @since 2.0.0
+ */
+export const copy: {
+  <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>
+  <A>(self: ReadonlyArray<A>): Array<A>
+} = (<A>(self: ReadonlyArray<A>): Array<A> => self.slice()) as any
+
 /**
  * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
  * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
@@ -1196,15 +1231,15 @@ export const splitNonEmptyAt: {
  *
  * whenever `n` evenly divides the length of `self`.
  *
- * @category getters
+ * @category splitting
  * @since 2.0.0
  */
 export const chunksOf: {
   (
     n: number
-  ): <T extends ReadonlyArray<any> | Iterable<any>>(
-    self: T
-  ) => ReadonlyArray.With<T, NonEmptyArray<ReadonlyArray.Infer<T>>>
+  ): <S extends ReadonlyArray<any> | Iterable<any>>(
+    self: S
+  ) => ReadonlyArray.With<S, NonEmptyArray<ReadonlyArray.Infer<S>>>
   <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<NonEmptyArray<A>>
   <A>(self: Iterable<A>, n: number): Array<NonEmptyArray<A>>
 } = dual(2, <A>(self: Iterable<A>, n: number): Array<NonEmptyArray<A>> => {
@@ -1283,7 +1318,7 @@ export const unionWith: {
   <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
     that: T,
     isEquivalent: (self: ReadonlyArray.Infer<S>, that: ReadonlyArray.Infer<T>) => boolean
-  ): (self: S) => ReadonlyArray.With2<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
+  ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(
     self: NonEmptyReadonlyArray<A>,
     that: Iterable<B>,
@@ -1316,7 +1351,7 @@ export const union: {
     that: T
   ): <S extends ReadonlyArray<any> | Iterable<any>>(
     self: S
-  ) => ReadonlyArray.With2<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
+  ) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: NonEmptyReadonlyArray<A>, that: ReadonlyArray<B>): NonEmptyArray<A | B>
   <A, B>(self: ReadonlyArray<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<A | B>
   <A, B>(self: Iterable<A>, that: Iterable<B>): Array<A | B>
@@ -1399,24 +1434,46 @@ export declare namespace ReadonlyArray {
   /**
    * @since 2.0.0
    */
-  export type Infer<T extends ReadonlyArray<any> | Iterable<any>> = T extends ReadonlyArray<infer A> ? A
-    : T extends Iterable<infer A> ? A
+  export type Infer<S extends ReadonlyArray<any> | Iterable<any>> = S extends ReadonlyArray<infer A> ? A
+    : S extends Iterable<infer A> ? A
     : never
 
   /**
    * @since 2.0.0
    */
-  export type With<T extends ReadonlyArray<any> | Iterable<any>, A> = T extends NonEmptyReadonlyArray<any> ?
+  export type With<S extends ReadonlyArray<any> | Iterable<any>, A> = S extends NonEmptyReadonlyArray<any> ?
     NonEmptyArray<A>
     : Array<A>
 
   /**
    * @since 2.0.0
    */
-  export type With2<S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>, A> =
-    S extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
-      : T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
-      : Array<A>
+  export type OrNonEmpty<
+    S extends ReadonlyArray<any> | Iterable<any>,
+    T extends ReadonlyArray<any> | Iterable<any>,
+    A
+  > = S extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
+    : T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
+    : Array<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type AndNonEmpty<
+    S extends ReadonlyArray<any> | Iterable<any>,
+    T extends ReadonlyArray<any> | Iterable<any>,
+    A
+  > = S extends NonEmptyReadonlyArray<any> ? T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
+    : Array<A>
+    : Array<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type Flatten<T extends ReadonlyArray<ReadonlyArray<any>>> = T extends
+    NonEmptyReadonlyArray<NonEmptyReadonlyArray<infer A>> ? NonEmptyArray<A>
+    : T extends ReadonlyArray<ReadonlyArray<infer A>> ? Array<A>
+    : never
 }
 
 /**
@@ -1424,10 +1481,10 @@ export declare namespace ReadonlyArray {
  * @since 2.0.0
  */
 export const map: {
-  <T extends ReadonlyArray<any>, B>(
-    f: (a: ReadonlyArray.Infer<T>, i: number) => B
-  ): (self: T) => ReadonlyArray.With<T, B>
-  <T extends ReadonlyArray<any>, B>(self: T, f: (a: ReadonlyArray.Infer<T>, i: number) => B): ReadonlyArray.With<T, B>
+  <S extends ReadonlyArray<any>, B>(
+    f: (a: ReadonlyArray.Infer<S>, i: number) => B
+  ): (self: S) => ReadonlyArray.With<S, B>
+  <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>
 } = dual(2, <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B> => self.map(f))
 
 /**
@@ -1439,7 +1496,7 @@ export const map: {
 export const flatMap: {
   <S extends ReadonlyArray<any>, T extends ReadonlyArray<any>>(
     f: (a: ReadonlyArray.Infer<S>, i: number) => T
-  ): (self: S) => ReadonlyArray.With2<S, T, ReadonlyArray.Infer<T>>
+  ): (self: S) => ReadonlyArray.AndNonEmpty<S, T, ReadonlyArray.Infer<T>>
   <A, B>(self: NonEmptyReadonlyArray<A>, f: (a: A, i: number) => NonEmptyReadonlyArray<B>): NonEmptyArray<B>
   <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => ReadonlyArray<B>): Array<B>
 } = dual(
@@ -1462,10 +1519,9 @@ export const flatMap: {
  * @category sequencing
  * @since 2.0.0
  */
-export const flatten: {
-  <A>(self: NonEmptyReadonlyArray<NonEmptyReadonlyArray<A>>): NonEmptyArray<A>
-  <A>(self: ReadonlyArray<ReadonlyArray<A>>): Array<A>
-} = flatMap(identity) as any
+export const flatten: <S extends ReadonlyArray<ReadonlyArray<any>>>(self: S) => ReadonlyArray.Flatten<S> = flatMap(
+  identity
+) as any
 
 /**
  * @category filtering
@@ -1865,9 +1921,9 @@ export const forEach: {
  * @since 2.0.0
  */
 export const dedupeWith: {
-  <A>(
-    isEquivalent: (self: A, that: A) => boolean
-  ): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>
+  <S extends ReadonlyArray<any> | Iterable<any>>(
+    isEquivalent: (self: ReadonlyArray.Infer<S>, that: ReadonlyArray.Infer<S>) => boolean
+  ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A>(self: NonEmptyReadonlyArray<A>, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray<A>
   <A>(self: Iterable<A>, isEquivalent: (self: A, that: A) => boolean): Array<A>
 } = dual(
@@ -1894,10 +1950,10 @@ export const dedupeWith: {
  *
  * @since 2.0.0
  */
-export const dedupe: {
-  <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>
-  <A>(self: Iterable<A>): Array<A>
-} = dedupeWith(Equal.equivalence()) as any
+export const dedupe = <S extends Iterable<any> | NonEmptyReadonlyArray<any>>(
+  self: S
+): S extends NonEmptyReadonlyArray<infer A> ? NonEmptyArray<A> : S extends Iterable<infer A> ? Array<A> : never =>
+  dedupeWith(self, Equal.equivalence()) as any
 
 /**
  * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.

package/src/ReadonlyRecord.ts

@@ -83,19 +83,19 @@ export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is Read
  * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
  *
  * @example
- * import { fromIterable } from "effect/ReadonlyRecord"
+ * import { fromIterableWith } from "effect/ReadonlyRecord"
  *
  * const input = [1, 2, 3, 4]
  *
  * assert.deepStrictEqual(
- *   fromIterable(input, a => [String(a), a * 2]),
+ *   fromIterableWith(input, a => [String(a), a * 2]),
  *   { '1': 2, '2': 4, '3': 6, '4': 8 }
  * )
  *
- * @category conversions
+ * @category constructors
  * @since 2.0.0
  */
-export const fromIterable: {
+export const fromIterableWith: {
   <A, B>(f: (a: A) => readonly [string, B]): (self: Iterable<A>) => Record<string, B>
   <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B>
 } = dual(2, <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B> => {
@@ -107,6 +107,16 @@ export const fromIterable: {
   return out
 })
 
+/**
+ * Creates a new record from an iterable collection of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Record<string, V> = fromIterableWith(
+  identity
+)
+
 /**
  * Builds a record from an iterable of key-value pairs.
  *
@@ -125,7 +135,7 @@ export const fromIterable: {
  * @category conversions
  * @since 2.0.0
  */
-export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<string, A> = fromIterable(identity)
+export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<string, A> = fromIterableWith(identity)
 
 /**
  * Transforms the values of a record into an `Array` with a custom mapping function.

package/src/RedBlackTree.ts

@@ -68,7 +68,7 @@ export const isRedBlackTree: {
 export const empty: <K, V = never>(ord: Order<K>) => RedBlackTree<K, V> = RBT.empty
 
 /**
- * Constructs a new tree from an iterable of key-value pairs.
+ * Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
  *
  * @since 2.0.0
  * @category constructors

package/src/ScheduleIntervals.ts

@@ -45,7 +45,7 @@ export const make: (intervals: Check.Chunk<Interval.Interval>) => Intervals = in
 export const empty: Intervals = internal.empty
 
 /**
- * Constructs `Intervals` from the specified `Iterable<Interval>`.
+ * Creates `Intervals` from the specified `Iterable<Interval>`.
  *
  * @since 2.0.0
  * @category constructors

package/src/Secret.ts

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

package/src/SortedMap.ts

@@ -88,6 +88,8 @@ export const isSortedMap: {
 export const empty = <K, V = never>(ord: Order<K>): SortedMap<K, V> => makeImpl<K, V>(RBT.empty<K, V>(ord))
 
 /**
+ * Creates a new `SortedMap` from an iterable collection of key/value pairs.
+ *
  * @since 2.0.0
  * @category constructors
  */

package/src/SortedSet.ts

@@ -87,6 +87,8 @@ export const isSortedSet: {
 export const empty = <A>(O: Order<A>): SortedSet<A> => fromTree(RBT.empty(O))
 
 /**
+ * Creates a new `SortedSet` from an iterable collection of values.
+ *
  * @since 2.0.0
  * @category constructors
  */

package/src/Stream.ts

@@ -1550,7 +1550,7 @@ export const fromPubSub: {
 } = internal.fromPubSub
 
 /**
- * Creates a stream from an `Iterable` collection of values.
+ * Creates a new `Stream` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/TArray.ts

@@ -298,7 +298,7 @@ export const forEach: {
 } = internal.forEach
 
 /**
- * Makes a new `TArray` initialized with provided iterable.
+ * Creates a new `TArray` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/TMap.ts

@@ -133,7 +133,7 @@ export const forEach: {
 } = internal.forEach
 
 /**
- * Makes a new `TMap` initialized with provided iterable.
+ * Creates a new `TMap` from an iterable collection of key/value pairs.
  *
  * @since 2.0.0
  * @category constructors

package/src/TPriorityQueue.ts

@@ -67,7 +67,7 @@ export declare namespace TPriorityQueue {
 export const empty: <A>(order: Order.Order<A>) => STM.STM<never, never, TPriorityQueue<A>> = internal.empty
 
 /**
- * Makes a new `TPriorityQueue` initialized with provided iterable.
+ * Creates a new `TPriorityQueue` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/TSet.ts

@@ -96,7 +96,7 @@ export const forEach: {
 } = internal.forEach
 
 /**
- * Makes a new `TSet` initialized with provided iterable.
+ * Creates a new `TSet` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/index.ts

@@ -154,11 +154,6 @@ export * as ConfigProvider from "./ConfigProvider.js"
  */
 export * as ConfigProviderPathPatch from "./ConfigProviderPathPatch.js"
 
-/**
- * @since 2.0.0
- */
-export * as ConfigSecret from "./ConfigSecret.js"
-
 /**
  * @since 2.0.0
  */
@@ -643,6 +638,11 @@ export * as ScopedCache from "./ScopedCache.js"
  */
 export * as ScopedRef from "./ScopedRef.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Secret from "./Secret.js"
+
 /**
  * @since 2.0.0
  */