effect 2.0.0-next.56 → 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.
@@ -568,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>;
 };
 /**
@@ -592,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...
@@ -609,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`.
@@ -716,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.
@@ -752,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
@@ -775,22 +723,13 @@ 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
@@ -807,7 +746,8 @@ 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
@@ -831,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.
@@ -876,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`.
@@ -936,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
@@ -964,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
@@ -979,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
@@ -1031,10 +946,53 @@ export declare const partitionMap: {
     <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 compact: <A>(self: Iterable<Option<A>>) => Array<A>;
+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 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
@@ -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: {
@@ -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.
  *