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

package/src/Graph.ts

@@ -19,7 +19,6 @@ import * as csr from "./internal/graphCsr.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
-import { hasProperty } from "./Predicate.ts"
 import type { Covariant, Invariant } from "./Types.ts"
 
 const TypeId = internal.TypeId
@@ -147,22 +146,6 @@ export interface Snapshot<out N, out E, out T extends Kind> {
   readonly edges: ReadonlyArray<IndexedEdge<E>>
 }
 
-/**
- * Common public protocol for graph values.
- *
- * **Details**
- *
- * Contains only the runtime marker and shared protocols. Graph storage is kept
- * internal; use module functions such as `nodes`, `edges`, `getNode`, and
- * `getEdge` to inspect graph contents.
- *
- * @category protocols
- * @since 3.18.0
- */
-export interface Proto<out N, out E> extends Iterable<readonly [NodeIndex, N]>, Equal.Equal, Pipeable, Inspectable {
-  readonly [TypeId]: Graph.Variance<N, E>
-}
-
 /**
  * Immutable graph interface.
  *
@@ -181,7 +164,10 @@ export interface Proto<out N, out E> extends Iterable<readonly [NodeIndex, N]>,
  * @category models
  * @since 3.18.0
  */
-export interface Graph<out N, out E, T extends Kind = "directed"> extends Proto<N, E> {
+export interface Graph<out N, out E, T extends Kind = "directed">
+  extends Iterable<readonly [NodeIndex, N]>, Equal.Equal, Pipeable, Inspectable
+{
+  readonly [TypeId]: Graph.Variance<N, E>
   readonly type: T
   readonly mutable: false
 }
@@ -415,9 +401,9 @@ const withMutationGuard = <N, E, T extends Kind, A>(
  * @category guards
  * @since 4.0.0
  */
-export const isGraph = <N = unknown, E = unknown, T extends Kind = Kind, U = never>(
+export const isGraph: <N = unknown, E = unknown, T extends Kind = Kind, U = never>(
   u: U | Graph<N, E, T> | MutableGraph<N, E, T>
-): u is Graph<N, E, T> | MutableGraph<N, E, T> => hasProperty(u, TypeId)
+) => u is Graph<N, E, T> | MutableGraph<N, E, T> = internal.isGraph
 
 /**
  * Reconstructs an immutable graph from its indexed active structure.
@@ -777,7 +763,7 @@ const mutateScoped = <N, E, T extends Kind>(
  *
  * **When to use**
  *
- * Use for the usual immutable update workflow when several node or edge
+ * Use when several node or edge
  * mutations should be applied together.
  *
  * **Details**
@@ -818,7 +804,7 @@ export const mutate: {
    *
    * **When to use**
    *
-   * Use for the usual immutable update workflow when several node or edge
+   * Use when several node or edge
    * mutations should be applied together.
    *
    * **Details**
@@ -859,7 +845,7 @@ export const mutate: {
    *
    * **When to use**
    *
-   * Use for the usual immutable update workflow when several node or edge
+   * Use when several node or edge
    * mutations should be applied together.
    *
    * **Details**
@@ -5190,6 +5176,8 @@ export const edgeCount = <N, E, T extends Kind = "directed">(
 /**
  * Returns the indices of all edges incident to a node.
  *
+ * **Details**
+ *
  * Each edge is returned once in graph edge order, including self-loops.
  * Throws a `GraphError` when the node does not exist.
  *
@@ -5200,6 +5188,8 @@ export const incidentEdges: {
   /**
    * Returns the indices of all edges incident to a node.
    *
+   * **Details**
+   *
    * Each edge is returned once in graph edge order, including self-loops.
    * Throws a `GraphError` when the node does not exist.
    *
@@ -5210,6 +5200,8 @@ export const incidentEdges: {
   /**
    * Returns the indices of all edges incident to a node.
    *
+   * **Details**
+   *
    * Each edge is returned once in graph edge order, including self-loops.
    * Throws a `GraphError` when the node does not exist.
    *
@@ -5265,6 +5257,8 @@ export const incidentEdges: {
 /**
  * Returns the indices of outgoing edges for a node in a directed graph.
  *
+ * **Details**
+ *
  * Parallel edges and self-loops are returned separately in adjacency order.
  * Throws a `GraphError` for an undirected graph or missing node.
  *
@@ -5275,6 +5269,8 @@ export const outgoingEdges: {
   /**
    * Returns the indices of outgoing edges for a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges and self-loops are returned separately in adjacency order.
    * Throws a `GraphError` for an undirected graph or missing node.
    *
@@ -5287,6 +5283,8 @@ export const outgoingEdges: {
   /**
    * Returns the indices of outgoing edges for a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges and self-loops are returned separately in adjacency order.
    * Throws a `GraphError` for an undirected graph or missing node.
    *
@@ -5314,6 +5312,8 @@ export const outgoingEdges: {
 /**
  * Returns the indices of incoming edges for a node in a directed graph.
  *
+ * **Details**
+ *
  * Parallel edges and self-loops are returned separately in reverse-adjacency
  * order. Throws a `GraphError` for an undirected graph or missing node.
  *
@@ -5324,6 +5324,8 @@ export const incomingEdges: {
   /**
    * Returns the indices of incoming edges for a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges and self-loops are returned separately in reverse-adjacency
    * order. Throws a `GraphError` for an undirected graph or missing node.
    *
@@ -5336,6 +5338,8 @@ export const incomingEdges: {
   /**
    * Returns the indices of incoming edges for a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges and self-loops are returned separately in reverse-adjacency
    * order. Throws a `GraphError` for an undirected graph or missing node.
    *
@@ -5363,6 +5367,8 @@ export const incomingEdges: {
 /**
  * Returns all edge indices connecting the supplied nodes.
  *
+ * **Details**
+ *
  * Directed graphs only include edges from `source` to `target`; undirected
  * graphs include either stored orientation. Parallel edges are retained.
  * Throws a `GraphError` when either node does not exist.
@@ -5374,6 +5380,8 @@ export const edgesBetween: {
   /**
    * Returns all edge indices connecting the supplied nodes.
    *
+   * **Details**
+   *
    * Directed graphs only include edges from `source` to `target`; undirected
    * graphs include either stored orientation. Parallel edges are retained.
    * Throws a `GraphError` when either node does not exist.
@@ -5387,6 +5395,8 @@ export const edgesBetween: {
   /**
    * Returns all edge indices connecting the supplied nodes.
    *
+   * **Details**
+   *
    * Directed graphs only include edges from `source` to `target`; undirected
    * graphs include either stored orientation. Parallel edges are retained.
    * Throws a `GraphError` when either node does not exist.
@@ -5430,6 +5440,8 @@ export const edgesBetween: {
 /**
  * Returns the degree of a node in an undirected graph.
  *
+ * **Details**
+ *
  * Parallel edges count separately and a self-loop contributes two. Throws a
  * `GraphError` for a directed graph or missing node.
  *
@@ -5440,6 +5452,8 @@ export const degree: {
   /**
    * Returns the degree of a node in an undirected graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes two. Throws a
    * `GraphError` for a directed graph or missing node.
    *
@@ -5452,6 +5466,8 @@ export const degree: {
   /**
    * Returns the degree of a node in an undirected graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes two. Throws a
    * `GraphError` for a directed graph or missing node.
    *
@@ -5479,6 +5495,8 @@ export const degree: {
 /**
  * Returns the out-degree of a node in a directed graph.
  *
+ * **Details**
+ *
  * Parallel edges count separately and a self-loop contributes one. Throws a
  * `GraphError` for an undirected graph or missing node.
  *
@@ -5489,6 +5507,8 @@ export const outDegree: {
   /**
    * Returns the out-degree of a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes one. Throws a
    * `GraphError` for an undirected graph or missing node.
    *
@@ -5501,6 +5521,8 @@ export const outDegree: {
   /**
    * Returns the out-degree of a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes one. Throws a
    * `GraphError` for an undirected graph or missing node.
    *
@@ -5528,6 +5550,8 @@ export const outDegree: {
 /**
  * Returns the in-degree of a node in a directed graph.
  *
+ * **Details**
+ *
  * Parallel edges count separately and a self-loop contributes one. Throws a
  * `GraphError` for an undirected graph or missing node.
  *
@@ -5538,6 +5562,8 @@ export const inDegree: {
   /**
    * Returns the in-degree of a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes one. Throws a
    * `GraphError` for an undirected graph or missing node.
    *
@@ -5550,6 +5576,8 @@ export const inDegree: {
   /**
    * Returns the in-degree of a node in a directed graph.
    *
+   * **Details**
+   *
    * Parallel edges count separately and a self-loop contributes one. Throws a
    * `GraphError` for an undirected graph or missing node.
    *
@@ -10244,7 +10272,7 @@ export const bellmanFord: {
   const edges = csr.getEdges(cache)
   const edgeIds = csr.getEdgeIds(cache)
   const edgeCache = csr.getEdgeEndpoints(cache)
-  const outgoing = csr.getOutgoing(cache)
+  const outgoing = csr.getOutgoingWithEdges(cache)
   const source = csr.getNodeIndex(cache, config.source)!
   const target = csr.getNodeIndex(cache, config.target)!
   const weights = new Float64Array(edges.length)
@@ -10337,7 +10365,9 @@ export const bellmanFord: {
     while (head < tail) {
       const node = queue[head++]
       for (let i = outgoing.rowOffsets[node]; i < outgoing.rowOffsets[node + 1]; i++) {
-        markAffected(outgoing.columnIndices[i])
+        if (weights[outgoing.edgeIndices[i]] !== Infinity) {
+          markAffected(outgoing.columnIndices[i])
+        }
       }
     }
   }

package/src/Hash.ts

@@ -28,7 +28,7 @@ import { hasProperty } from "./Predicate.ts"
  * @category symbols
  * @since 2.0.0
  */
-export const symbol = "~effect/interfaces/Hash"
+export const symbol = "~effect/Hash"
 
 /**
  * A type that represents an object that can be hashed.
@@ -106,10 +106,6 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
       return number(self)
     case "bigint":
       return string(self.toString(10))
-    case "boolean":
-      return string(String(self))
-    case "symbol":
-      return string(String(self))
     case "string":
       return string(self)
     case "undefined":
@@ -153,9 +149,8 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
       }
     }
     default:
-      throw new Error(
-        `BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`
-      )
+      // The remaining primitive types are boolean and symbol.
+      return string(String(self))
   }
 }
 
@@ -380,14 +375,8 @@ export const isHash = (u: unknown): u is Hash => hasProperty(u, symbol)
  * @since 2.0.0
  */
 export const number = (n: number) => {
-  if (n !== n) {
-    return string("NaN")
-  }
-  if (n === Infinity) {
-    return string("Infinity")
-  }
-  if (n === -Infinity) {
-    return string("-Infinity")
+  if (n !== n || n === Infinity || n === -Infinity) {
+    return string(String(n))
   }
   let h = n | 0
   if (h !== n) {

package/src/HashRing.ts

@@ -12,12 +12,13 @@
 import { dual } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
+import * as Count from "./internal/count.ts"
 import * as Iterable from "./Iterable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as PrimaryKey from "./PrimaryKey.ts"
 
-const TypeId = "~effect/cluster/HashRing" as const
+const TypeId = "~effect/HashRing" as const
 
 /**
  * A weighted consistent-hashing ring for assigning inputs to nodes with stable
@@ -484,6 +485,11 @@ export const get = <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, input: s
  * Use to precompute ownership for a fixed number of shard indexes across the
  * current ring members.
  *
+ * **Details**
+ *
+ * Finite fractional values of `count` are rounded down. `NaN` and non-positive
+ * values produce an empty shard distribution.
+ *
  * @category combinators
  * @since 3.19.0
  */
@@ -491,6 +497,7 @@ export const getShards = <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, co
   if (self.ring.length === 0) {
     return undefined
   }
+  count = Count.normalize(count)
 
   const shards = new Array<A>(count)
 
@@ -585,7 +592,7 @@ function getIndexForInput<A extends PrimaryKey.PrimaryKey>(
     return [a, distA]
   }
   const range = Math.max(lo, len - lo)
-  for (let i = 1; i < range; i++) {
+  for (let i = 1; i <= range; i++) {
     let index = lo - i
     if (index >= 0 && index < len && !exclude.has(ring[index][1])) {
       return [index, Math.abs(ring[index][0] - hash)]

package/src/HashSet.ts

@@ -899,11 +899,67 @@ export const filter: {
   <V>(self: HashSet<V>, predicate: Predicate<V>): HashSet<V>
 } = Dual.dual<
   {
+    /**
+     * Filters the HashSet keeping only values that satisfy the predicate.
+     *
+     * **Example** (Filtering HashSet values)
+     *
+     * ```ts import.meta.vitest
+     * import { HashSet } from "effect"
+     *
+     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
+     * ```
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <V, U extends V>(refinement: Refinement<NoInfer<V>, U>): (self: HashSet<V>) => HashSet<U>
+    /**
+     * Filters the HashSet keeping only values that satisfy the predicate.
+     *
+     * **Example** (Filtering HashSet values)
+     *
+     * ```ts import.meta.vitest
+     * import { HashSet } from "effect"
+     *
+     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
+     * ```
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <V>(predicate: Predicate<NoInfer<V>>): (self: HashSet<V>) => HashSet<V>
   },
   {
+    /**
+     * Filters the HashSet keeping only values that satisfy the predicate.
+     *
+     * **Example** (Filtering HashSet values)
+     *
+     * ```ts import.meta.vitest
+     * import { HashSet } from "effect"
+     *
+     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
+     * ```
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <V, U extends V>(self: HashSet<V>, refinement: Refinement<V, U>): HashSet<U>
+    /**
+     * Filters the HashSet keeping only values that satisfy the predicate.
+     *
+     * **Example** (Filtering HashSet values)
+     *
+     * ```ts import.meta.vitest
+     * import { HashSet } from "effect"
+     *
+     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
+     * ```
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <V>(self: HashSet<V>, predicate: Predicate<V>): HashSet<V>
   }
 >(2, internal.filter)

package/src/Iterable.ts

@@ -12,6 +12,7 @@
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
 import { dual } from "./Function.ts"
+import * as Count from "./internal/count.ts"
 import * as InternalRecord from "./internal/record.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
@@ -27,9 +28,9 @@ import type { NoInfer } from "./Types.ts"
  *
  * **Details**
  *
- * The function is called with each index starting from `0`. If no length is
- * specified, the iterable is infinite. This is useful for generating
- * sequences, patterns, or any indexed data.
+ * The function is called with each index starting from `0`. If a length is
+ * provided, it is rounded down and normalized to at least `1`, with `NaN`
+ * treated as `1`. If no length is specified, the iterable is infinite.
  *
  * **Example** (Generating values by index)
  *
@@ -56,7 +57,7 @@ import type { NoInfer } from "./Types.ts"
 export const makeBy = <A>(f: (i: number) => A, options?: {
   readonly length?: number
 }): Iterable<A> => {
-  const max = options?.length !== undefined ? Math.max(1, Math.floor(options.length)) : Infinity
+  const max = options?.length !== undefined ? Count.normalizeNonEmpty(options.length) : Infinity
   return {
     [Symbol.iterator]() {
       let i = 0
@@ -106,7 +107,8 @@ export const range = (start: number, end?: number): Iterable<number> => {
  *
  * **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** (Repeating a value)
  *
@@ -125,7 +127,8 @@ export const replicate: {
    *
    * **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** (Repeating a value)
    *
@@ -144,7 +147,8 @@ export const replicate: {
    *
    * **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** (Repeating a value)
    *
@@ -170,7 +174,8 @@ export const replicate: {
  *
  * **Details**
  *
- * The result is lazy. Each repetition obtains a new iterator from `self`.
+ * The result is lazy. `n` is rounded down and normalized to at least `1`, with
+ * `NaN` treated as `1`. Each repetition obtains a new iterator from `self`.
  *
  * @see {@link forever} for repeating without an upper bound
  * @see {@link replicate} for repeating a single value
@@ -188,7 +193,8 @@ export const repeat: {
    *
    * **Details**
    *
-   * The result is lazy. Each repetition obtains a new iterator from `self`.
+   * The result is lazy. `n` is rounded down and normalized to at least `1`, with
+   * `NaN` treated as `1`. Each repetition obtains a new iterator from `self`.
    *
    * @see {@link forever} for repeating without an upper bound
    * @see {@link replicate} for repeating a single value
@@ -206,7 +212,8 @@ export const repeat: {
    *
    * **Details**
    *
-   * The result is lazy. Each repetition obtains a new iterator from `self`.
+   * The result is lazy. `n` is rounded down and normalized to at least `1`, with
+   * `NaN` treated as `1`. Each repetition obtains a new iterator from `self`.
    *
    * @see {@link forever} for repeating without an upper bound
    * @see {@link replicate} for repeating a single value
@@ -877,7 +884,8 @@ export const headUnsafe = <A>(self: Iterable<A>): A => {
  *
  * **Details**
  *
- * `n` is normalized to a non-negative integer.
+ * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+ * treated as `0`.
  *
  * **Example** (Taking from the start)
  *
@@ -911,7 +919,8 @@ export const take: {
    *
    * **Details**
    *
-   * `n` is normalized to a non-negative integer.
+   * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+   * treated as `0`.
    *
    * **Example** (Taking from the start)
    *
@@ -945,7 +954,8 @@ export const take: {
    *
    * **Details**
    *
-   * `n` is normalized to a non-negative integer.
+   * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+   * treated as `0`.
    *
    * **Example** (Taking from the start)
    *
@@ -974,21 +984,24 @@ export const take: {
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, n: number): Iterable<A>
-} = dual(2, <A>(self: Iterable<A>, n: number): Iterable<A> => ({
-  [Symbol.iterator]() {
-    let i = 0
-    const iterator = self[Symbol.iterator]()
-    return {
-      next() {
-        if (i < n) {
-          i++
-          return iterator.next()
+} = dual(2, <A>(self: Iterable<A>, n: number): Iterable<A> => {
+  const count = Count.normalize(n)
+  return {
+    [Symbol.iterator]() {
+      let i = 0
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          if (i < count) {
+            i++
+            return iterator.next()
+          }
+          return { done: true, value: undefined }
         }
-        return { done: true, value: undefined }
       }
     }
   }
-}))
+})
 
 /**
  * Takes the longest initial `Iterable` prefix for which all elements satisfy the
@@ -1191,7 +1204,8 @@ export const takeWhile: {
  *
  * **Details**
  *
- * `n` is normalized to a non-negative integer.
+ * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+ * treated as `0`.
  *
  * **Example** (Dropping from the start)
  *
@@ -1224,7 +1238,8 @@ export const drop: {
    *
    * **Details**
    *
-   * `n` is normalized to a non-negative integer.
+   * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+   * treated as `0`.
    *
    * **Example** (Dropping from the start)
    *
@@ -1257,7 +1272,8 @@ export const drop: {
    *
    * **Details**
    *
-   * `n` is normalized to a non-negative integer.
+   * `n` is rounded down and normalized to a non-negative integer. `NaN` is
+   * treated as `0`.
    *
    * **Example** (Dropping from the start)
    *
@@ -1285,24 +1301,27 @@ export const drop: {
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, n: number): Iterable<A>
-} = dual(2, <A>(self: Iterable<A>, n: number): Iterable<A> => ({
-  [Symbol.iterator]() {
-    const iterator = self[Symbol.iterator]()
-    let i = 0
-    return {
-      next() {
-        while (i < n) {
-          const result = iterator.next()
-          if (result.done) {
-            return { done: true, value: undefined }
+} = dual(2, <A>(self: Iterable<A>, n: number): Iterable<A> => {
+  const count = Count.normalize(n)
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      let i = 0
+      return {
+        next() {
+          while (i < count) {
+            const result = iterator.next()
+            if (result.done) {
+              return { done: true, value: undefined }
+            }
+            i++
           }
-          i++
+          return iterator.next()
         }
-        return iterator.next()
       }
     }
   }
-}))
+})
 
 /**
  * Returns the first element that satisfies the specified
@@ -2465,6 +2484,8 @@ export const contains: {
 /**
  * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
  * the `Iterable`.
+ * `n` is rounded down and normalized to at least `1`; `NaN` and non-positive
+ * values therefore produce singleton pieces.
  *
  * **Example** (Chunking an iterable)
  *
@@ -2502,6 +2523,8 @@ export const chunksOf: {
   /**
    * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
    * the `Iterable`.
+   * `n` is rounded down and normalized to at least `1`; `NaN` and non-positive
+   * values therefore produce singleton pieces.
    *
    * **Example** (Chunking an iterable)
    *
@@ -2539,6 +2562,8 @@ export const chunksOf: {
   /**
    * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
    * the `Iterable`.
+   * `n` is rounded down and normalized to at least `1`; `NaN` and non-positive
+   * values therefore produce singleton pieces.
    *
    * **Example** (Chunking an iterable)
    *
@@ -2574,7 +2599,7 @@ export const chunksOf: {
    */
   <A>(self: Iterable<A>, n: number): Iterable<Array<A>>
 } = dual(2, <A>(self: Iterable<A>, n: number): Iterable<Array<A>> => {
-  const safeN = Math.max(1, Math.floor(n))
+  const safeN = Count.normalizeNonEmpty(n)
   return ({
     [Symbol.iterator]() {
       let iterator: Iterator<A> | undefined = self[Symbol.iterator]()