effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/Chunk.ts

@@ -19,6 +19,7 @@ import { dual, identity, pipe } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import type { TypeLambda } from "./HKT.ts"
 import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
+import * as Count from "./internal/count.ts"
 import type { NonEmptyIterable } from "./NonEmptyIterable.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
@@ -30,7 +31,7 @@ import * as R from "./Result.ts"
 import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
 
-const TypeId = "~effect/collections/Chunk"
+const TypeId = "~effect/Chunk"
 
 /**
  * A Chunk is an immutable, ordered collection optimized for efficient concatenation and access patterns.
@@ -248,7 +249,7 @@ const makeChunk = <A>(backing: Backing<A>): Chunk<A> => {
     }
     case "ISlice": {
       chunk.length = backing.length
-      chunk.depth = backing.chunk.depth + 1
+      chunk.depth = 0
       chunk.left = _empty
       chunk.right = _empty
       break
@@ -944,6 +945,7 @@ export const prepend: {
 
 /**
  * Takes the first up to `n` elements from the chunk.
+ * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
  *
  * **Example** (Taking elements from the start)
  *
@@ -960,6 +962,7 @@ export const prepend: {
 export const take: {
   /**
    * Takes the first up to `n` elements from the chunk.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Taking elements from the start)
    *
@@ -976,6 +979,7 @@ export const take: {
   (n: number): <A>(self: Chunk<A>) => Chunk<A>
   /**
    * Takes the first up to `n` elements from the chunk.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Taking elements from the start)
    *
@@ -991,7 +995,7 @@ export const take: {
    */
   <A>(self: Chunk<A>, n: number): Chunk<A>
 } = dual(2, <A>(self: Chunk<A>, _n: number): Chunk<A> => {
-  const n = Math.floor(_n)
+  const n = Count.normalize(_n)
   if (n <= 0) {
     return _empty
   } else if (n >= self.length) {
@@ -1031,6 +1035,7 @@ export const take: {
 
 /**
  * Drops the first up to `n` elements from the chunk.
+ * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
  *
  * **Example** (Dropping elements from the start)
  *
@@ -1047,6 +1052,7 @@ export const take: {
 export const drop: {
   /**
    * Drops the first up to `n` elements from the chunk.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Dropping elements from the start)
    *
@@ -1063,6 +1069,7 @@ export const drop: {
   (n: number): <A>(self: Chunk<A>) => Chunk<A>
   /**
    * Drops the first up to `n` elements from the chunk.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Dropping elements from the start)
    *
@@ -1078,7 +1085,7 @@ export const drop: {
    */
   <A>(self: Chunk<A>, n: number): Chunk<A>
 } = dual(2, <A>(self: Chunk<A>, _n: number): Chunk<A> => {
-  const n = Math.floor(_n)
+  const n = Count.normalize(_n)
   if (n <= 0) {
     return self
   } else if (n >= self.length) {
@@ -1117,6 +1124,7 @@ export const drop: {
 
 /**
  * Drops the last `n` elements.
+ * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
  *
  * **Example** (Dropping elements from the end)
  *
@@ -1133,6 +1141,7 @@ export const drop: {
 export const dropRight: {
   /**
    * Drops the last `n` elements.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Dropping elements from the end)
    *
@@ -1149,6 +1158,7 @@ export const dropRight: {
   (n: number): <A>(self: Chunk<A>) => Chunk<A>
   /**
    * Drops the last `n` elements.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Dropping elements from the end)
    *
@@ -1163,7 +1173,10 @@ export const dropRight: {
    * @since 2.0.0
    */
   <A>(self: Chunk<A>, n: number): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, n: number): Chunk<A> => take(self, Math.max(0, self.length - n)))
+} = dual(
+  2,
+  <A>(self: Chunk<A>, n: number): Chunk<A> => take(self, self.length - Math.min(Count.normalize(n), self.length))
+)
 
 /**
  * Drops all elements so long as the predicate returns true.
@@ -2105,12 +2118,13 @@ export const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Flatten<S>
  *
  * **Details**
  *
- * The final chunk may contain fewer than `n` elements. Empty input produces an
- * empty chunk of chunks.
+ * `n` is rounded down and normalized to at least `1`. The final chunk may
+ * contain fewer than `n` elements. Empty input produces an empty chunk of
+ * chunks.
  *
  * **Gotchas**
  *
- * Values of `n` less than or equal to zero produce singleton chunks.
+ * `NaN` and values of `n` less than or equal to zero produce singleton chunks.
  *
  * **Example** (Splitting into fixed-size chunks)
  *
@@ -2144,12 +2158,13 @@ export const chunksOf: {
    *
    * **Details**
    *
-   * The final chunk may contain fewer than `n` elements. Empty input produces an
-   * empty chunk of chunks.
+   * `n` is rounded down and normalized to at least `1`. The final chunk may
+   * contain fewer than `n` elements. Empty input produces an empty chunk of
+   * chunks.
    *
    * **Gotchas**
    *
-   * Values of `n` less than or equal to zero produce singleton chunks.
+   * `NaN` and values of `n` less than or equal to zero produce singleton chunks.
    *
    * **Example** (Splitting into fixed-size chunks)
    *
@@ -2183,12 +2198,13 @@ export const chunksOf: {
    *
    * **Details**
    *
-   * The final chunk may contain fewer than `n` elements. Empty input produces an
-   * empty chunk of chunks.
+   * `n` is rounded down and normalized to at least `1`. The final chunk may
+   * contain fewer than `n` elements. Empty input produces an empty chunk of
+   * chunks.
    *
    * **Gotchas**
    *
-   * Values of `n` less than or equal to zero produce singleton chunks.
+   * `NaN` and values of `n` less than or equal to zero produce singleton chunks.
    *
    * **Example** (Splitting into fixed-size chunks)
    *
@@ -2213,11 +2229,12 @@ export const chunksOf: {
    */
   <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>
 } = dual(2, <A>(self: Chunk<A>, n: number) => {
+  const size = Count.normalizeNonEmpty(n)
   const gr: Array<Chunk<A>> = []
   let current: Array<A> = []
   toReadonlyArray(self).forEach((a) => {
     current.push(a)
-    if (current.length >= n) {
+    if (current.length >= size) {
       gr.push(fromArrayUnsafe(current))
       current = []
     }
@@ -3232,9 +3249,9 @@ export const splitAt: {
  *
  * **Details**
  *
- * `n` is floored and normalized to at least `1`. If `n` is greater than or
- * equal to the chunk length, the first result is the original chunk and the
- * second result is empty.
+ * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+ * `1`. If `n` is greater than or equal to the chunk length, the first result is
+ * the original chunk and the second result is empty.
  *
  * **Example** (Splitting non-empty chunks at an index)
  *
@@ -3265,9 +3282,9 @@ export const splitNonEmptyAt: {
    *
    * **Details**
    *
-   * `n` is floored and normalized to at least `1`. If `n` is greater than or
-   * equal to the chunk length, the first result is the original chunk and the
-   * second result is empty.
+   * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+   * `1`. If `n` is greater than or equal to the chunk length, the first result is
+   * the original chunk and the second result is empty.
    *
    * **Example** (Splitting non-empty chunks at an index)
    *
@@ -3298,9 +3315,9 @@ export const splitNonEmptyAt: {
    *
    * **Details**
    *
-   * `n` is floored and normalized to at least `1`. If `n` is greater than or
-   * equal to the chunk length, the first result is the original chunk and the
-   * second result is empty.
+   * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+   * `1`. If `n` is greater than or equal to the chunk length, the first result is
+   * the original chunk and the second result is empty.
    *
    * **Example** (Splitting non-empty chunks at an index)
    *
@@ -3326,7 +3343,7 @@ export const splitNonEmptyAt: {
    */
   <A>(self: NonEmptyChunk<A>, n: number): [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>]
 } = dual(2, <A>(self: NonEmptyChunk<A>, n: number): [Chunk<A>, Chunk<A>] => {
-  const _n = Math.max(1, Math.floor(n))
+  const _n = Count.normalizeNonEmpty(n)
   return _n >= self.length ?
     [self, empty()] :
     [take(self, _n), drop(self, _n)]
@@ -3337,8 +3354,9 @@ export const splitNonEmptyAt: {
  *
  * **Details**
  *
- * The chunk size is derived from the input length and `n`; the final chunk may
- * contain fewer elements than the others.
+ * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+ * `1`. The chunk size is derived from the input length and normalized count;
+ * the final chunk may contain fewer elements than the others.
  *
  * **Example** (Splitting chunks into groups)
  *
@@ -3368,8 +3386,9 @@ export const split: {
    *
    * **Details**
    *
-   * The chunk size is derived from the input length and `n`; the final chunk may
-   * contain fewer elements than the others.
+   * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+   * `1`. The chunk size is derived from the input length and normalized count;
+   * the final chunk may contain fewer elements than the others.
    *
    * **Example** (Splitting chunks into groups)
    *
@@ -3399,8 +3418,9 @@ export const split: {
    *
    * **Details**
    *
-   * The chunk size is derived from the input length and `n`; the final chunk may
-   * contain fewer elements than the others.
+   * `n` is rounded down and normalized to at least `1`, with `NaN` treated as
+   * `1`. The chunk size is derived from the input length and normalized count;
+   * the final chunk may contain fewer elements than the others.
    *
    * **Example** (Splitting chunks into groups)
    *
@@ -3425,7 +3445,7 @@ export const split: {
    * @since 2.0.0
    */
   <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>
-} = dual(2, <A>(self: Chunk<A>, n: number) => chunksOf(self, Math.ceil(self.length / Math.floor(n))))
+} = dual(2, <A>(self: Chunk<A>, n: number) => chunksOf(self, Math.ceil(self.length / Count.normalizeNonEmpty(n))))
 
 /**
  * Splits this chunk on the first element that matches this predicate.
@@ -3573,6 +3593,7 @@ export const tailNonEmpty = <A>(self: NonEmptyChunk<A>): Chunk<A> => drop(self,
 
 /**
  * Takes the last `n` elements.
+ * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
  *
  * **Example** (Taking elements from the end)
  *
@@ -3595,6 +3616,7 @@ export const tailNonEmpty = <A>(self: NonEmptyChunk<A>): Chunk<A> => drop(self,
 export const takeRight: {
   /**
    * Takes the last `n` elements.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Taking elements from the end)
    *
@@ -3617,6 +3639,7 @@ export const takeRight: {
   (n: number): <A>(self: Chunk<A>) => Chunk<A>
   /**
    * Takes the last `n` elements.
+   * `n` is rounded down, with `NaN` and non-positive values treated as `0`.
    *
    * **Example** (Taking elements from the end)
    *
@@ -3637,7 +3660,10 @@ export const takeRight: {
    * @since 2.0.0
    */
   <A>(self: Chunk<A>, n: number): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, n: number): Chunk<A> => drop(self, self.length - n))
+} = dual(
+  2,
+  <A>(self: Chunk<A>, n: number): Chunk<A> => drop(self, self.length - Math.min(Count.normalize(n), self.length))
+)
 
 /**
  * Takes all elements so long as the predicate returns true.
@@ -4285,7 +4311,8 @@ export const replace: {
  *
  * **Details**
  *
- * `n` is normalized to an integer greater than or equal to `1`.
+ * `n` is rounded down and normalized to an integer greater than or equal to
+ * `1`. `NaN` is treated as `1`.
  *
  * **Example** (Generating chunks from indices)
  *
@@ -4304,7 +4331,8 @@ export const makeBy: {
    *
    * **Details**
    *
-   * `n` is normalized to an integer greater than or equal to `1`.
+   * `n` is rounded down and normalized to an integer greater than or equal to
+   * `1`. `NaN` is treated as `1`.
    *
    * **Example** (Generating chunks from indices)
    *
@@ -4323,7 +4351,8 @@ export const makeBy: {
    *
    * **Details**
    *
-   * `n` is normalized to an integer greater than or equal to `1`.
+   * `n` is rounded down and normalized to an integer greater than or equal to
+   * `1`. `NaN` is treated as `1`.
    *
    * **Example** (Generating chunks from indices)
    *