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

package/dist/dts/ReadonlyArray.d.ts

@@ -155,22 +155,25 @@ export declare const prepend: {
     <A, B>(self: Iterable<A>, head: B): NonEmptyArray<A | B>;
 };
 /**
+ * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable).
+ * If either array is non-empty, the result is also a non-empty array.
+ *
+ * @example
+ * import * as ReadonlyArray from "effect/ReadonlyArray"
+ *
+ * assert.deepStrictEqual(
+ *   ReadonlyArray.prependAll([1, 2], ["a", "b"]),
+ *   ["a", "b", 1, 2]
+ * )
+ *
  * @category concatenating
  * @since 2.0.0
  */
 export declare const prependAll: {
-    <B>(that: Iterable<B>): <A>(self: Iterable<A>) => Array<A | B>;
-    <A, B>(self: Iterable<A>, that: Iterable<B>): Array<A | B>;
-};
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export declare const prependAllNonEmpty: {
-    <B>(that: NonEmptyReadonlyArray<B>): <A>(self: Iterable<A>) => NonEmptyArray<A | B>;
-    <B>(that: Iterable<B>): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A | B>;
+    <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>>;
     <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>;
 };
 /**
  * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`.
@@ -183,22 +186,17 @@ export declare const append: {
     <A, B>(self: Iterable<A>, last: B): NonEmptyArray<A | B>;
 };
 /**
+ * Concatenates two arrays (or iterables), combining their elements.
+ * If either array is non-empty, the result is also a non-empty array.
+ *
  * @category concatenating
  * @since 2.0.0
  */
 export declare const appendAll: {
-    <B>(that: Iterable<B>): <A>(self: Iterable<A>) => Array<A | B>;
-    <A, B>(self: Iterable<A>, that: Iterable<B>): Array<A | B>;
-};
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export declare const appendAllNonEmpty: {
-    <B>(that: NonEmptyReadonlyArray<B>): <A>(self: Iterable<A>) => NonEmptyArray<A | B>;
-    <B>(that: Iterable<B>): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A | B>;
+    <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>>;
     <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>;
 };
 /**
  * Reduce an `Iterable` from the left, keeping all intermediate results instead of only the final result.
@@ -317,14 +315,14 @@ export declare const unsafeGet: {
  * @category getters
  * @since 2.0.0
  */
-export declare const unprepend: <A>(self: readonly [A, ...A[]]) => [A, A[]];
+export declare const unprepend: <A>(self: readonly [A, ...A[]]) => [firstElement: A, remainingElements: A[]];
 /**
  * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
  *
  * @category getters
  * @since 2.0.0
  */
-export declare const unappend: <A>(self: readonly [A, ...A[]]) => [A[], A];
+export declare const unappend: <A>(self: readonly [A, ...A[]]) => [arrayWithoutLastElement: A[], lastElement: A];
 /**
  * Get the first element of a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
  *
@@ -407,9 +405,9 @@ export declare const takeRight: {
  */
 export declare const takeWhile: {
     <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Array<B>;
-    <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Array<B>;
+    <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>;
     <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Array<B>;
-    <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B>;
+    <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>;
 };
 /**
  * Split an `Iterable` into two parts:
@@ -421,10 +419,10 @@ export declare const takeWhile: {
  * @since 2.0.0
  */
 export declare const span: {
-    <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => [init: Array<B>, rest: Array<A>];
-    <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => [init: Array<B>, rest: Array<B>];
-    <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): [init: Array<B>, rest: Array<A>];
-    <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): [init: Array<B>, rest: Array<B>];
+    <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Iterable<C>) => [init: Array<B>, rest: Array<Exclude<C, B>>];
+    <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => [init: Array<B>, rest: Array<B>];
+    <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): [init: Array<B>, rest: Array<Exclude<A, B>>];
+    <A>(self: Iterable<A>, predicate: Predicate<A>): [init: Array<A>, rest: Array<A>];
 };
 /**
  * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`.
@@ -457,10 +455,8 @@ export declare const dropRight: {
  * @since 2.0.0
  */
 export declare const dropWhile: {
-    <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Array<B>;
-    <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Array<B>;
-    <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Array<B>;
-    <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B>;
+    <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>;
+    <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>;
 };
 /**
  * Return the first index for which a predicate holds.
@@ -491,9 +487,9 @@ export declare const findLastIndex: {
  */
 export declare const findFirst: {
     <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Option<B>;
-    <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Option<B>;
+    <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Option<B>;
     <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Option<B>;
-    <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B>;
+    <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A>;
 };
 /**
  * Find the last element for which a predicate holds.
@@ -503,9 +499,9 @@ export declare const findFirst: {
  */
 export declare const findLast: {
     <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Option<B>;
-    <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Option<B>;
+    <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Option<B>;
     <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Option<B>;
-    <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B>;
+    <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A>;
 };
 /**
  * Insert an element at the specified index, creating a new `NonEmptyArray`,
@@ -570,20 +566,20 @@ export declare const remove: {
  * @category elements
  * @since 2.0.0
  */
-export declare const reverse: <A>(self: Iterable<A>) => A[];
-/**
- * @category elements
- * @since 2.0.0
- */
-export declare const reverseNonEmpty: <A>(self: readonly [A, ...A[]]) => [A, ...A[]];
+export declare const reverse: {
+    <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>;
+    <A>(self: Iterable<A>): Array<A>;
+};
 /**
- * Sort the elements of an `Iterable` in increasing order, creating a new `Array`.
+ * Create a new array with elements sorted in increasing order based on the specified comparator.
+ * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`.
  *
  * @category sorting
  * @since 2.0.0
  */
 export declare const sort: {
-    <B>(O: Order.Order<B>): <A extends B>(self: Iterable<A>) => Array<A>;
+    <B>(O: Order.Order<B>): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>;
+    <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>;
 };
 /**
@@ -594,16 +590,6 @@ export declare const sortWith: {
     <A, B>(f: (a: A) => B, order: Order.Order<B>): (self: ReadonlyArray<A>) => Array<A>;
     <A, B>(self: ReadonlyArray<A>, f: (a: A) => B, order: Order.Order<B>): Array<A>;
 };
-/**
- * Sort the elements of a `NonEmptyReadonlyArray` in increasing order, creating a new `NonEmptyArray`.
- *
- * @category sorting
- * @since 2.0.0
- */
-export declare const sortNonEmpty: {
-    <B>(O: Order.Order<B>): <A extends B>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
-    <A extends B, B>(self: NonEmptyReadonlyArray<A>, O: Order.Order<B>): NonEmptyArray<A>;
-};
 /**
  * Sort the elements of an `Iterable` in increasing order, where elements are compared
  * using first `orders[0]`, then `orders[1]`, etc...
@@ -611,74 +597,56 @@ export declare const sortNonEmpty: {
  * @category sorting
  * @since 2.0.0
  */
-export declare const sortBy: <B>(...orders: readonly Order.Order<B>[]) => <A extends B>(self: Iterable<A>) => A[];
-/**
- * @category sorting
- * @since 2.0.0
- */
-export declare const sortByNonEmpty: <B>(...orders: readonly Order.Order<B>[]) => <A extends B>(as: readonly [A, ...A[]]) => [A, ...A[]];
+export declare const sortBy: <B>(...orders: readonly Order.Order<B>[]) => {
+    <A extends B>(as: readonly [A, ...A[]]): [A, ...A[]];
+    <A_1 extends B>(self: Iterable<A_1>): A_1[];
+};
 /**
  * Takes two `Iterable`s and returns an `Array` of corresponding pairs.
  * If one input `Iterable` is short, excess elements of the
  * longer `Iterable` are discarded.
  *
+ * @category zipping
  * @since 2.0.0
  */
 export declare const zip: {
+    <B>(that: NonEmptyReadonlyArray<B>): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<[A, B]>;
     <B>(that: Iterable<B>): <A>(self: Iterable<A>) => Array<[A, B]>;
+    <A, B>(self: NonEmptyReadonlyArray<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<[A, B]>;
     <A, B>(self: Iterable<A>, that: Iterable<B>): Array<[A, B]>;
 };
 /**
  * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
  * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
  *
+ * @category zipping
  * @since 2.0.0
  */
 export declare const zipWith: {
-    <B, A, C>(that: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Array<C>;
-    <B, A, C>(self: Iterable<A>, that: Iterable<B>, f: (a: A, b: B) => C): Array<C>;
-};
-/**
- * @since 2.0.0
- */
-export declare const zipNonEmpty: {
-    <B>(that: NonEmptyReadonlyArray<B>): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<[A, B]>;
-    <A, B>(self: NonEmptyReadonlyArray<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<[A, B]>;
-};
-/**
- * @since 2.0.0
- */
-export declare const zipNonEmptyWith: {
     <B, A, C>(that: NonEmptyReadonlyArray<B>, f: (a: A, b: B) => C): (self: NonEmptyReadonlyArray<A>) => NonEmptyArray<C>;
+    <B, A, C>(that: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Array<C>;
     <A, B, C>(self: NonEmptyReadonlyArray<A>, that: NonEmptyReadonlyArray<B>, f: (a: A, b: B) => C): NonEmptyArray<C>;
+    <B, A, C>(self: Iterable<A>, that: Iterable<B>, f: (a: A, b: B) => C): Array<C>;
 };
 /**
  * This function is the inverse of `zip`. Takes an `Iterable` of pairs and return two corresponding `Array`s.
  *
  * @since 2.0.0
  */
-export declare const unzip: <A, B>(self: Iterable<readonly [A, B]>) => [A[], B[]];
-/**
- * @since 2.0.0
- */
-export declare const unzipNonEmpty: <A, B>(self: readonly [readonly [A, B], ...(readonly [A, B])[]]) => [[A, ...A[]], [B, ...B[]]];
-/**
- * Places an element in between members of an `Iterable`
- *
- * @since 2.0.0
- */
-export declare const intersperse: {
-    <B>(middle: B): <A>(self: Iterable<A>) => Array<A | B>;
-    <A, B>(self: Iterable<A>, middle: B): Array<A | B>;
+export declare const unzip: {
+    <A, B>(self: NonEmptyReadonlyArray<readonly [A, B]>): [NonEmptyArray<A>, NonEmptyArray<B>];
+    <A, B>(self: Iterable<readonly [A, B]>): [Array<A>, Array<B>];
 };
 /**
- * Places an element in between members of a `NonEmptyReadonlyArray`
+ * Places an element in between members of an `Iterable`.
+ * If the input is a non-empty array, the result is also a non-empty array.
  *
  * @since 2.0.0
  */
-export declare const intersperseNonEmpty: {
-    <B>(middle: B): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A | B>;
+export declare const intersperse: {
+    <B>(middle: B): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>;
     <A, B>(self: NonEmptyReadonlyArray<A>, middle: B): NonEmptyArray<A | B>;
+    <A, B>(self: Iterable<A>, middle: B): Array<A | B>;
 };
 /**
  * Apply a function to the head, creating a new `NonEmptyReadonlyArray`.
@@ -718,21 +686,14 @@ export declare const setNonEmptyLast: {
 };
 /**
  * Rotate an `Iterable` by `n` steps.
+ * If the input is a non-empty array, the result is also a non-empty array.
  *
  * @since 2.0.0
  */
 export declare const rotate: {
-    (n: number): <A>(self: Iterable<A>) => Array<A>;
-    <A>(self: Iterable<A>, n: number): Array<A>;
-};
-/**
- * Rotate a `NonEmptyReadonlyArray` by `n` steps.
- *
- * @since 2.0.0
- */
-export declare const rotateNonEmpty: {
-    (n: number): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
+    (n: number): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>;
     <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<A>;
+    <A>(self: Iterable<A>, n: number): Array<A>;
 };
 /**
  * Returns a function that checks if a `ReadonlyArray` contains a given value using a provided `isEquivalent` function.
@@ -754,21 +715,6 @@ export declare const contains: {
     <A>(a: A): (self: Iterable<A>) => boolean;
     <A>(self: Iterable<A>, a: A): boolean;
 };
-/**
- * Remove duplicates from a `NonEmptyReadonlyArray`, keeping the first occurrence of an element using the provided `isEquivalent` function.
- *
- * @since 2.0.0
- */
-export declare const dedupeNonEmptyWith: {
-    <A>(isEquivalent: (self: A, that: A) => boolean): (self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
-    <A>(self: NonEmptyReadonlyArray<A>, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray<A>;
-};
-/**
- * Remove duplicates from a `NonEmptyReadonlyArray`, keeping the first occurrence of an element.
- *
- * @since 2.0.0
- */
-export declare const dedupeNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
 /**
  * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input
  * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a
@@ -777,29 +723,20 @@ export declare const dedupeNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => NonE
  * @since 2.0.0
  */
 export declare const chop: {
-    <A, B>(f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): (self: Iterable<A>) => Array<B>;
-    <A, B>(self: Iterable<A>, f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): Array<B>;
-};
-/**
- * A useful recursion pattern for processing a `NonEmptyReadonlyArray` to produce a new `NonEmptyReadonlyArray`, often used for "chopping" up the input
- * `NonEmptyReadonlyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `NonEmptyReadonlyArray` and produce a
- * value and the tail of the `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-export declare const chopNonEmpty: {
-    <A, B>(f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): (self: NonEmptyReadonlyArray<A>) => NonEmptyArray<B>;
+    <A, B>(f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>;
     <A, B>(self: NonEmptyReadonlyArray<A>, f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): NonEmptyArray<B>;
+    <A, B>(self: Iterable<A>, f: (as: NonEmptyReadonlyArray<A>) => readonly [B, ReadonlyArray<A>]): Array<B>;
 };
 /**
- * Splits an `Iterable` into two pieces, the first piece has max `n` elements.
+ * 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
  * @since 2.0.0
  */
 export declare const splitAt: {
-    (n: number): <A>(self: Iterable<A>) => [Array<A>, Array<A>];
-    <A>(self: Iterable<A>, n: number): [Array<A>, Array<A>];
+    (n: number): <A>(self: Iterable<A>) => [beforeIndex: Array<A>, fromIndex: Array<A>];
+    <A>(self: Iterable<A>, n: number): [beforeIndex: Array<A>, fromIndex: Array<A>];
 };
 /**
  * @since 2.0.0
@@ -809,14 +746,15 @@ export declare const copy: {
     <A>(self: ReadonlyArray<A>): Array<A>;
 };
 /**
- * Splits a `NonEmptyReadonlyArray` into two pieces, the first piece has max `n` elements.
+ * 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
  * @since 2.0.0
  */
 export declare const splitNonEmptyAt: {
-    (n: number): <A>(self: NonEmptyReadonlyArray<A>) => [NonEmptyArray<A>, Array<A>];
-    <A>(self: NonEmptyReadonlyArray<A>, n: number): [NonEmptyArray<A>, Array<A>];
+    (n: number): <A>(self: NonEmptyReadonlyArray<A>) => [beforeIndex: NonEmptyArray<A>, fromIndex: Array<A>];
+    <A>(self: NonEmptyReadonlyArray<A>, n: number): [beforeIndex: NonEmptyArray<A>, fromIndex: Array<A>];
 };
 /**
  * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
@@ -833,19 +771,9 @@ export declare const splitNonEmptyAt: {
  * @since 2.0.0
  */
 export declare const chunksOf: {
-    (n: number): <A>(self: Iterable<A>) => Array<NonEmptyArray<A>>;
-    <A>(self: Iterable<A>, n: number): Array<NonEmptyArray<A>>;
-};
-/**
- * Splits a `NonEmptyReadonlyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
- * the `NonEmptyReadonlyArray`.
- *
- * @category getters
- * @since 2.0.0
- */
-export declare const chunksOfNonEmpty: {
-    (n: number): <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<NonEmptyArray<A>>;
+    (n: number): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, NonEmptyArray<ReadonlyArray.Infer<T>>>;
     <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<NonEmptyArray<A>>;
+    <A>(self: Iterable<A>, n: number): Array<NonEmptyArray<A>>;
 };
 /**
  * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function.
@@ -878,35 +806,21 @@ export declare const groupBy: {
 /**
  * @since 2.0.0
  */
-export declare const unionWith: <A>(isEquivalent: (self: A, that: A) => boolean) => {
-    (that: Iterable<A>): (self: Iterable<A>) => A[];
-    (self: Iterable<A>, that: Iterable<A>): A[];
+export declare 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>>;
+    <A, B>(self: NonEmptyReadonlyArray<A>, that: Iterable<B>, isEquivalent: (self: A, that: B) => boolean): NonEmptyArray<A | B>;
+    <A, B>(self: Iterable<A>, that: NonEmptyReadonlyArray<B>, isEquivalent: (self: A, that: B) => boolean): NonEmptyArray<A | B>;
+    <A, B>(self: Iterable<A>, that: Iterable<B>, isEquivalent: (self: A, that: B) => boolean): Array<A | B>;
 };
 /**
  * @since 2.0.0
  */
 export declare const union: {
-    <B>(that: Iterable<B>): <A>(self: Iterable<A>) => Array<A | B>;
+    <T extends ReadonlyArray<any> | Iterable<any>>(that: T): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With2<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>;
 };
-/**
- * @since 2.0.0
- */
-export declare const unionNonEmptyWith: <A>(isEquivalent: (self: A, that: A) => boolean) => {
-    (that: readonly [A, ...A[]]): (self: readonly A[]) => [A, ...A[]];
-    (that: readonly A[]): (self: readonly [A, ...A[]]) => [A, ...A[]];
-    (self: readonly A[], that: readonly [A, ...A[]]): [A, ...A[]];
-    (self: readonly [A, ...A[]], that: readonly A[]): [A, ...A[]];
-};
-/**
- * @since 2.0.0
- */
-export declare const unionNonEmpty: {
-    <A>(that: NonEmptyReadonlyArray<A>): (self: ReadonlyArray<A>) => NonEmptyArray<A>;
-    <A>(that: ReadonlyArray<A>): (self: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
-    <A>(self: ReadonlyArray<A>, that: NonEmptyReadonlyArray<A>): NonEmptyArray<A>;
-    <A>(self: NonEmptyReadonlyArray<A>, that: ReadonlyArray<A>): NonEmptyArray<A>;
-};
 /**
  * Creates an `Array` of unique values that are included in all given `Iterable`s using the provided `isEquivalent` function.
  * The order and references of result values are determined by the first `Iterable`.
@@ -938,7 +852,7 @@ export declare const differenceWith: <A>(isEquivalent: (self: A, that: A) => boo
     (self: Iterable<A>, that: Iterable<A>): A[];
 };
 /**
- * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function.
+ * Creates a `Array` of values not included in the other given `Iterable`.
  * The order and references of result values are determined by the first `Iterable`.
  *
  * @since 2.0.0
@@ -966,11 +880,15 @@ export declare namespace ReadonlyArray {
     /**
      * @since 2.0.0
      */
-    type Infer<T extends ReadonlyArray<any>> = T[number];
+    type Infer<T extends ReadonlyArray<any> | Iterable<any>> = T extends ReadonlyArray<infer A> ? A : T extends Iterable<infer A> ? A : never;
+    /**
+     * @since 2.0.0
+     */
+    type With<T extends ReadonlyArray<any> | Iterable<any>, A> = T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A> : Array<A>;
     /**
      * @since 2.0.0
      */
-    type With<T extends ReadonlyArray<any>, A> = T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A> : Array<A>;
+    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>;
 }
 /**
  * @category mapping
@@ -981,31 +899,26 @@ export declare const map: {
     <T extends ReadonlyArray<any>, B>(self: T, f: (a: ReadonlyArray.Infer<T>, i: number) => B): ReadonlyArray.With<T, B>;
 };
 /**
+ * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements.
+ *
  * @category sequencing
  * @since 2.0.0
  */
 export declare const flatMap: {
-    <A, B>(f: (a: A, i: number) => ReadonlyArray<B>): (self: ReadonlyArray<A>) => Array<B>;
+    <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>>;
+    <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>;
 };
 /**
+ * Flattens an array of arrays into a single array by concatenating all arrays.
+ *
  * @category sequencing
  * @since 2.0.0
  */
-export declare const flatMapNonEmpty: {
-    <A, B>(f: (a: A, i: number) => NonEmptyReadonlyArray<B>): (self: NonEmptyReadonlyArray<A>) => NonEmptyArray<B>;
-    <A, B>(self: NonEmptyReadonlyArray<A>, f: (a: A, i: number) => NonEmptyReadonlyArray<B>): NonEmptyArray<B>;
+export declare const flatten: {
+    <A>(self: NonEmptyReadonlyArray<NonEmptyReadonlyArray<A>>): NonEmptyArray<A>;
+    <A>(self: ReadonlyArray<ReadonlyArray<A>>): Array<A>;
 };
-/**
- * @category sequencing
- * @since 2.0.0
- */
-export declare const flatten: <A>(self: ReadonlyArray<ReadonlyArray<A>>) => Array<A>;
-/**
- * @category sequencing
- * @since 2.0.0
- */
-export declare const flattenNonEmpty: <A>(self: NonEmptyReadonlyArray<NonEmptyReadonlyArray<A>>) => NonEmptyArray<A>;
 /**
  * @category filtering
  * @since 2.0.0
@@ -1029,33 +942,78 @@ export declare const filterMapWhile: {
  * @since 2.0.0
  */
 export declare const partitionMap: {
-    <A, B, C>(f: (a: A, i: number) => Either<B, C>): (self: Iterable<A>) => [Array<B>, Array<C>];
-    <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [Array<B>, Array<C>];
+    <A, B, C>(f: (a: A, i: number) => Either<B, C>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>];
+    <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [left: Array<B>, right: Array<C>];
 };
 /**
+ * Retrieves the `Some` values from an `Iterable` of `Option`s, collecting them into an array.
+ *
+ * @example
+ * import { getSomes } from "effect/ReadonlyArray"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(
+ *   getSomes([some(1), none(), some(2)]),
+ *   [1, 2]
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export declare const getSomes: <A>(self: Iterable<Option<A>>) => Array<A>;
+/**
+ * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
+ *
+ * @example
+ * import { getLefts } from "effect/ReadonlyArray"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getLefts([right(1), left("err"), right(2)]),
+ *   ["err"]
+ * )
+ *
  * @category filtering
  * @since 2.0.0
  */
-export declare const compact: <A>(self: Iterable<Option<A>>) => Array<A>;
+export declare const getLefts: <E, A>(self: Iterable<Either<E, A>>) => E[];
+/**
+ * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array.
+ *
+ * @example
+ * import { getRights } from "effect/ReadonlyArray"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getRights([right(1), left("err"), right(2)]),
+ *   [1, 2]
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export declare const getRights: <E, A>(self: Iterable<Either<E, A>>) => A[];
 /**
  * @category filtering
  * @since 2.0.0
  */
 export declare const filter: {
-    <C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (self: Iterable<C>) => Array<B>;
-    <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>;
-    <C extends A, B extends A, A = C>(self: Iterable<C>, refinement: (a: A, i: number) => a is B): Array<B>;
-    <B extends A, A = B>(self: Iterable<B>, predicate: (a: A, i: number) => boolean): Array<B>;
+    <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>;
+    <A, B extends A>(predicate: (b: B, i: number) => boolean): (self: Iterable<A>) => Array<A>;
+    <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>;
+    <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>;
 };
 /**
+ * Separate elements based on a predicate that also exposes the index of the element.
+ *
  * @category filtering
  * @since 2.0.0
  */
 export declare const partition: {
-    <C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (self: Iterable<C>) => [Array<C>, Array<B>];
-    <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => [Array<B>, Array<B>];
-    <C extends A, B extends A, A = C>(self: Iterable<C>, refinement: (a: A, i: number) => a is B): [Array<C>, Array<B>];
-    <B extends A, A = B>(self: Iterable<B>, predicate: (a: A, i: number) => boolean): [Array<B>, Array<B>];
+    <C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (self: Iterable<C>) => [excluded: Array<Exclude<C, B>>, satisfying: Array<B>];
+    <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => [excluded: Array<B>, satisfying: Array<B>];
+    <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): [excluded: Array<Exclude<A, B>>, satisfying: Array<B>];
+    <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [excluded: Array<A>, satisfying: Array<A>];
 };
 /**
  * @category filtering
@@ -1083,8 +1041,8 @@ export declare const reduceRight: {
  * @since 2.0.0
  */
 export declare const liftPredicate: {
-    <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (c: C) => Array<B>;
-    <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Array<B>;
+    <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Array<B>;
+    <A>(predicate: Predicate<A>): <B extends A>(b: B) => Array<B>;
 };
 /**
  * @category lifting
@@ -1102,7 +1060,7 @@ export declare const fromNullable: <A>(a: A) => NonNullable<A>[];
  */
 export declare const liftNullable: <A extends unknown[], B>(f: (...a: A) => B | null | undefined) => (...a: A) => NonNullable<B>[];
 /**
- * @category combining
+ * @category sequencing
  * @since 2.0.0
  */
 export declare const flatMapNullable: {
@@ -1133,8 +1091,8 @@ export declare const every: {
  * @since 2.0.0
  */
 export declare const some: {
-    <A>(predicate: Predicate<A>): <B extends A>(self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>;
-    <B extends A, A = B>(self: ReadonlyArray<B>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<B>;
+    <B extends A, A = B>(predicate: Predicate<A>): (self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>;
+    <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<A>;
 };
 /**
  * @since 2.0.0
@@ -1187,20 +1145,26 @@ export declare const forEach: {
     <A>(self: Iterable<A>, f: (a: A, i: number) => void): void;
 };
 /**
- * Remove duplicates from am `Iterable` using the provided `isEquivalent` function, keeping the first occurrence of an element.
+ * Remove duplicates from an `Iterable` using the provided `isEquivalent` function,
+ * preserving the order of the first occurrence of each element.
  *
  * @since 2.0.0
  */
 export declare const dedupeWith: {
-    <A>(isEquivalent: (self: A, that: A) => boolean): (self: Iterable<A>) => Array<A>;
+    <A>(isEquivalent: (self: A, that: A) => boolean): <T extends ReadonlyArray<any> | Iterable<any>>(self: T) => ReadonlyArray.With<T, ReadonlyArray.Infer<T>>;
+    <A>(self: NonEmptyReadonlyArray<A>, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray<A>;
     <A>(self: Iterable<A>, isEquivalent: (self: A, that: A) => boolean): Array<A>;
 };
 /**
- * Remove duplicates from am `Iterable`, keeping the first occurrence of an element.
+ * Remove duplicates from an `Iterable`, preserving the order of the first occurrence of each element.
+ * The equivalence used to compare elements is provided by `Equal.equivalence()` from the `Equal` module.
  *
  * @since 2.0.0
  */
-export declare const dedupe: <A>(self: Iterable<A>) => Array<A>;
+export declare const dedupe: {
+    <A>(self: NonEmptyReadonlyArray<A>): NonEmptyArray<A>;
+    <A>(self: Iterable<A>): Array<A>;
+};
 /**
  * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
  *
@@ -1233,8 +1197,8 @@ export declare const join: {
  * @category folding
  */
 export declare const mapAccum: {
-    <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Iterable<A>) => [S, Array<B>];
-    <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Array<B>];
+    <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Iterable<A>) => [state: S, mappedArray: Array<B>];
+    <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [state: S, mappedArray: Array<B>];
 };
 /**
  * Zips this chunk crosswise with the specified chunk using the specified combiner.