effect 3.13.9 → 3.13.11

package/src/Array.ts

@@ -4,21 +4,18 @@
  * @since 2.0.0
  */
 
-import type { Either } from "./Either.js"
-import * as E from "./Either.js"
+import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
 import type { LazyArg } from "./Function.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
-import * as readonlyArray from "./internal/array.js"
-import * as doNotation from "./internal/doNotation.js"
-import * as EffectIterable from "./Iterable.js"
-import type { Option } from "./Option.js"
-import * as O from "./Option.js"
+import * as internalArray from "./internal/array.js"
+import * as internalDoNotation from "./internal/doNotation.js"
+import * as moduleIterable from "./Iterable.js"
+import * as Option from "./Option.js"
 import * as Order from "./Order.js"
-import type { Predicate, Refinement } from "./Predicate.js"
-import { isBoolean } from "./Predicate.js"
+import * as Predicate from "./Predicate.js"
 import * as Record from "./Record.js"
 import * as Tuple from "./Tuple.js"
 import type { NoInfer } from "./Types.js"
@@ -286,7 +283,7 @@ export const fromRecord: <K extends string, A>(self: Readonly<Record<K, A>>) =>
  * @category conversions
  * @since 2.0.0
  */
-export const fromOption: <A>(self: Option<A>) => Array<A> = O.toArray
+export const fromOption: <A>(self: Option.Option<A>) => Array<A> = Option.toArray
 
 /**
  * Matches the elements of an array, applying functions to cases of empty and non-empty arrays.
@@ -1010,7 +1007,7 @@ export const isEmptyReadonlyArray: <A>(self: ReadonlyArray<A>) => self is readon
  * @category guards
  * @since 2.0.0
  */
-export const isNonEmptyArray: <A>(self: Array<A>) => self is NonEmptyArray<A> = readonlyArray.isNonEmptyArray
+export const isNonEmptyArray: <A>(self: Array<A>) => self is NonEmptyArray<A> = internalArray.isNonEmptyArray
 
 /**
  * Determine if a `ReadonlyArray` is non empty narrowing down the type to `NonEmptyReadonlyArray`.
@@ -1030,7 +1027,7 @@ export const isNonEmptyArray: <A>(self: Array<A>) => self is NonEmptyArray<A> =
  * @since 2.0.0
  */
 export const isNonEmptyReadonlyArray: <A>(self: ReadonlyArray<A>) => self is NonEmptyReadonlyArray<A> =
-  readonlyArray.isNonEmptyArray
+  internalArray.isNonEmptyArray
 
 /**
  * Return the number of elements in a `ReadonlyArray`.
@@ -1040,7 +1037,7 @@ export const isNonEmptyReadonlyArray: <A>(self: ReadonlyArray<A>) => self is Non
  */
 export const length = <A>(self: ReadonlyArray<A>): number => self.length
 
-const isOutOfBound = <A>(i: number, as: ReadonlyArray<A>): boolean => i < 0 || i >= as.length
+const isOutOfBounds = <A>(i: number, as: ReadonlyArray<A>): boolean => i < 0 || i >= as.length
 
 const clamp = <A>(i: number, as: ReadonlyArray<A>): number => Math.floor(Math.min(Math.max(0, i), as.length))
 
@@ -1057,17 +1054,17 @@ export const get: {
    * @category getters
    * @since 2.0.0
    */
-  (index: number): <A>(self: ReadonlyArray<A>) => Option<A>
+  (index: number): <A>(self: ReadonlyArray<A>) => Option.Option<A>
   /**
    * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`.
    *
    * @category getters
    * @since 2.0.0
    */
-  <A>(self: ReadonlyArray<A>, index: number): Option<A>
-} = dual(2, <A>(self: ReadonlyArray<A>, index: number): Option<A> => {
+  <A>(self: ReadonlyArray<A>, index: number): Option.Option<A>
+} = dual(2, <A>(self: ReadonlyArray<A>, index: number): Option.Option<A> => {
   const i = Math.floor(index)
-  return isOutOfBound(i, self) ? O.none() : O.some(self[i])
+  return isOutOfBounds(i, self) ? Option.none() : Option.some(self[i])
 })
 
 /**
@@ -1093,7 +1090,7 @@ export const unsafeGet: {
   <A>(self: ReadonlyArray<A>, index: number): A
 } = dual(2, <A>(self: ReadonlyArray<A>, index: number): A => {
   const i = Math.floor(index)
-  if (isOutOfBound(i, self)) {
+  if (isOutOfBounds(i, self)) {
     throw new Error(`Index ${i} out of bounds`)
   }
   return self[i]
@@ -1143,7 +1140,7 @@ export const unappend = <A>(
  * @category getters
  * @since 2.0.0
  */
-export const head: <A>(self: ReadonlyArray<A>) => Option<A> = get(0)
+export const head: <A>(self: ReadonlyArray<A>) => Option.Option<A> = get(0)
 
 /**
  * Get the first element of a non empty array.
@@ -1168,8 +1165,8 @@ export const headNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => A = unsafeGet(
  * @category getters
  * @since 2.0.0
  */
-export const last = <A>(self: ReadonlyArray<A>): Option<A> =>
-  isNonEmptyReadonlyArray(self) ? O.some(lastNonEmpty(self)) : O.none()
+export const last = <A>(self: ReadonlyArray<A>): Option.Option<A> =>
+  isNonEmptyReadonlyArray(self) ? Option.some(lastNonEmpty(self)) : Option.none()
 
 /**
  * Get the last element of a non empty array.
@@ -1194,9 +1191,9 @@ export const lastNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): A => self[self.
  * @category getters
  * @since 2.0.0
  */
-export const tail = <A>(self: Iterable<A>): Option<Array<A>> => {
+export const tail = <A>(self: Iterable<A>): Option.Option<Array<A>> => {
   const input = fromIterable(self)
-  return isNonEmptyReadonlyArray(input) ? O.some(tailNonEmpty(input)) : O.none()
+  return isNonEmptyReadonlyArray(input) ? Option.some(tailNonEmpty(input)) : Option.none()
 }
 
 /**
@@ -1222,9 +1219,9 @@ export const tailNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): Array<A> => sel
  * @category getters
  * @since 2.0.0
  */
-export const init = <A>(self: Iterable<A>): Option<Array<A>> => {
+export const init = <A>(self: Iterable<A>): Option.Option<Array<A>> => {
   const input = fromIterable(self)
-  return isNonEmptyReadonlyArray(input) ? O.some(initNonEmpty(input)) : O.none()
+  return isNonEmptyReadonlyArray(input) ? Option.some(initNonEmpty(input)) : Option.none()
 }
 
 /**
@@ -1756,7 +1753,7 @@ export const findFirstIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<number>
   /**
    * Return the first index for which a predicate holds.
    *
@@ -1772,16 +1769,16 @@ export const findFirstIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
-} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number> => {
   let i = 0
   for (const a of self) {
     if (predicate(a, i)) {
-      return O.some(i)
+      return Option.some(i)
     }
     i++
   }
-  return O.none()
+  return Option.none()
 })
 
 /**
@@ -1815,7 +1812,7 @@ export const findLastIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<number>
   /**
    * Return the last index for which a predicate holds.
    *
@@ -1831,15 +1828,15 @@ export const findLastIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
-} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number> => {
   const input = fromIterable(self)
   for (let i = input.length - 1; i >= 0; i--) {
     if (predicate(input[i], i)) {
-      return O.some(i)
+      return Option.some(i)
     }
   }
-  return O.none()
+  return Option.none()
 })
 
 /**
@@ -1875,7 +1872,7 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
+  <A, B>(f: (a: NoInfer<A>, i: number) => Option.Option<B>): (self: Iterable<A>) => Option.Option<B>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -1892,7 +1889,7 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option.Option<B>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -1909,7 +1906,7 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<A>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -1926,7 +1923,7 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Option.Option<B>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -1943,7 +1940,7 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option.Option<B>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -1960,8 +1957,8 @@ export const findFirst: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
-} = EffectIterable.findFirst
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<A>
+} = moduleIterable.findFirst
 
 /**
  * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
@@ -1996,7 +1993,7 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
+  <A, B>(f: (a: NoInfer<A>, i: number) => Option.Option<B>): (self: Iterable<A>) => Option.Option<B>
   /**
    * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
    * Returns an `Option` containing the found element, or `Option.none` if no element matches.
@@ -2013,7 +2010,7 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option.Option<B>
   /**
    * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
    * Returns an `Option` containing the found element, or `Option.none` if no element matches.
@@ -2030,7 +2027,7 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<A>
   /**
    * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
    * Returns an `Option` containing the found element, or `Option.none` if no element matches.
@@ -2047,7 +2044,7 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Option.Option<B>
   /**
    * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
    * Returns an `Option` containing the found element, or `Option.none` if no element matches.
@@ -2064,7 +2061,7 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option.Option<B>
   /**
    * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
    * Returns an `Option` containing the found element, or `Option.none` if no element matches.
@@ -2081,25 +2078,28 @@ export const findLast: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<A>
 } = dual(
   2,
-  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)): Option<A> => {
+  <A>(
+    self: Iterable<A>,
+    f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option.Option<A>)
+  ): Option.Option<A> => {
     const input = fromIterable(self)
     for (let i = input.length - 1; i >= 0; i--) {
       const a = input[i]
       const o = f(a, i)
-      if (isBoolean(o)) {
+      if (Predicate.isBoolean(o)) {
         if (o) {
-          return O.some(a)
+          return Option.some(a)
         }
       } else {
-        if (O.isSome(o)) {
+        if (Option.isSome(o)) {
           return o
         }
       }
     }
-    return O.none()
+    return Option.none()
   }
 )
 
@@ -2134,7 +2134,7 @@ export const insertAt: {
    *
    * @since 2.0.0
    */
-  <B>(i: number, b: B): <A>(self: Iterable<A>) => Option<NonEmptyArray<A | B>>
+  <B>(i: number, b: B): <A>(self: Iterable<A>) => Option.Option<NonEmptyArray<A | B>>
   /**
    * Insert an element at the specified index, creating a new `NonEmptyArray`,
    * or return `None` if the index is out of bounds.
@@ -2150,15 +2150,15 @@ export const insertAt: {
    *
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, i: number, b: B): Option<NonEmptyArray<A | B>>
-} = dual(3, <A, B>(self: Iterable<A>, i: number, b: B): Option<NonEmptyArray<A | B>> => {
+  <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<NonEmptyArray<A | B>>
+} = dual(3, <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<NonEmptyArray<A | B>> => {
   const out: Array<A | B> = Array.from(self)
   //             v--- `= self.length` is ok, it means inserting in last position
   if (i < 0 || i > out.length) {
-    return O.none()
+    return Option.none()
   }
   out.splice(i, 0, b)
-  return O.some(out) as any
+  return Option.some(out) as any
 })
 
 /**
@@ -2242,7 +2242,9 @@ export const replaceOption: {
    *
    * @since 2.0.0
    */
-  <B>(i: number, b: B): <A, S extends Iterable<A> = Iterable<A>>(self: S) => Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+  <B>(i: number, b: B): <A, S extends Iterable<A> = Iterable<A>>(
+    self: S
+  ) => Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
   /**
    * Replaces an element in an array with the given value, returning an option of the updated array.
    *
@@ -2257,10 +2259,10 @@ export const replaceOption: {
    *
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, b: B): Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, b: B): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(
   3,
-  <A, B>(self: Iterable<A>, i: number, b: B): Option<Array<A | B>> => modifyOption(self, i, () => b)
+  <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<Array<A | B>> => modifyOption(self, i, () => b)
 )
 
 /**
@@ -2314,7 +2316,7 @@ export const modify: {
 } = dual(
   3,
   <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> =>
-    O.getOrElse(modifyOption(self, i, f), () => Array.from(self))
+    Option.getOrElse(modifyOption(self, i, f), () => Array.from(self))
 )
 
 /**
@@ -2356,7 +2358,7 @@ export const modifyOption: {
    *
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(i: number, f: (a: ReadonlyArray.Infer<S>) => B): (self: S) => Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+  <A, B, S extends Iterable<A> = Iterable<A>>(i: number, f: (a: ReadonlyArray.Infer<S>) => B): (self: S) => Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
   /**
    * Apply a function to the element at the specified index, creating a new `Array`,
    * or return `None` if the index is out of bounds.
@@ -2376,16 +2378,16 @@ export const modifyOption: {
    *
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
-} = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option<Array<A | B>> => {
-  const out = Array.from(self)
-  if (isOutOfBound(i, out)) {
-    return O.none()
+  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+} = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option.Option<Array<A | B>> => {
+  const arr = Array.from(self)
+  if (isOutOfBounds(i, arr)) {
+    return Option.none()
   }
-  const next = f(out[i])
-  // @ts-expect-error
-  out[i] = next
-  return O.some(out)
+  const out: Array<A | B> = arr
+  const b = f(arr[i])
+  out[i] = b
+  return Option.some(out)
 })
 
 /**
@@ -2450,7 +2452,7 @@ export const remove: {
   <A>(self: Iterable<A>, i: number): Array<A>
 } = dual(2, <A>(self: Iterable<A>, i: number): Array<A> => {
   const out = Array.from(self)
-  if (isOutOfBound(i, out)) {
+  if (isOutOfBounds(i, out)) {
     return out
   }
   out.splice(i, 1)
@@ -3250,7 +3252,7 @@ export const rotate: {
   if (isNonEmptyReadonlyArray(input)) {
     const len = input.length
     const m = Math.round(n) % len
-    if (isOutOfBound(Math.abs(m), input) || m === 0) {
+    if (isOutOfBounds(Math.abs(m), input) || m === 0) {
       return copy(input)
     }
     if (m < 0) {
@@ -3450,7 +3452,7 @@ export const chop: {
     const [b, rest] = f(input)
     const out: NonEmptyArray<B> = [b]
     let next: ReadonlyArray<A> = rest
-    while (readonlyArray.isNonEmptyArray(next)) {
+    while (internalArray.isNonEmptyArray(next)) {
       const [b, rest] = f(next)
       out.push(b)
       next = rest
@@ -4644,7 +4646,7 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Array<B>
+  <A, B>(f: (a: A, i: number) => Option.Option<B>): (self: Iterable<A>) => Array<B>
   /**
    * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`.
    * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass.
@@ -4663,15 +4665,15 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Array<B>
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Array<B>
 } = dual(
   2,
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Array<B> => {
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Array<B> => {
     const as = fromIterable(self)
     const out: Array<B> = []
     for (let i = 0; i < as.length; i++) {
       const o = f(as[i], i)
-      if (O.isSome(o)) {
+      if (Option.isSome(o)) {
         out.push(o.value)
       }
     }
@@ -4718,7 +4720,7 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Array<B>
+  <A, B>(f: (a: A, i: number) => Option.Option<B>): (self: Iterable<A>) => Array<B>
   /**
    * Applies a function to each element of the array and filters based on the result, stopping when a condition is not met.
    * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`.
@@ -4738,13 +4740,13 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Array<B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => {
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Array<B>
+} = dual(2, <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>) => {
   let i = 0
   const out: Array<B> = []
   for (const a of self) {
     const b = f(a, i)
-    if (O.isSome(b)) {
+    if (Option.isSome(b)) {
       out.push(b.value)
     } else {
       break
@@ -4807,7 +4809,7 @@ export const partitionMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, C>(f: (a: A, i: number) => Either<C, B>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>]
+  <A, B, C>(f: (a: A, i: number) => Either.Either<C, B>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>]
   /**
    * Applies a function to each element of the `Iterable`, categorizing the results into two separate arrays.
    * This function is particularly useful for operations where each element can result in two possible types,
@@ -4834,16 +4836,16 @@ export const partitionMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<C, B>): [left: Array<B>, right: Array<C>]
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either.Either<C, B>): [left: Array<B>, right: Array<C>]
 } = dual(
   2,
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<C, B>): [left: Array<B>, right: Array<C>] => {
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either.Either<C, B>): [left: Array<B>, right: Array<C>] => {
     const left: Array<B> = []
     const right: Array<C> = []
     const as = fromIterable(self)
     for (let i = 0; i < as.length; i++) {
       const e = f(as[i], i)
-      if (E.isLeft(e)) {
+      if (Either.isLeft(e)) {
         left.push(e.left)
       } else {
         right.push(e.right)
@@ -4869,9 +4871,9 @@ export const partitionMap: {
  * @since 2.0.0
  */
 
-export const getSomes: <T extends Iterable<Option<X>>, X = any>(
+export const getSomes: <T extends Iterable<Option.Option<X>>, X = any>(
   self: T
-) => Array<Option.Value<ReadonlyArray.Infer<T>>> = filterMap(identity as any)
+) => Array<Option.Option.Value<ReadonlyArray.Infer<T>>> = filterMap(identity as any)
 
 /**
  * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
@@ -4888,10 +4890,12 @@ export const getSomes: <T extends Iterable<Option<X>>, X = any>(
  * @category filtering
  * @since 2.0.0
  */
-export const getLefts = <T extends Iterable<Either<any, any>>>(self: T): Array<Either.Left<ReadonlyArray.Infer<T>>> => {
+export const getLefts = <T extends Iterable<Either.Either<any, any>>>(
+  self: T
+): Array<Either.Either.Left<ReadonlyArray.Infer<T>>> => {
   const out: Array<any> = []
   for (const a of self) {
-    if (E.isLeft(a)) {
+    if (Either.isLeft(a)) {
       out.push(a.left)
     }
   }
@@ -4914,12 +4918,12 @@ export const getLefts = <T extends Iterable<Either<any, any>>>(self: T): Array<E
  * @category filtering
  * @since 2.0.0
  */
-export const getRights = <T extends Iterable<Either<any, any>>>(
+export const getRights = <T extends Iterable<Either.Either<any, any>>>(
   self: T
-): Array<Either.Right<ReadonlyArray.Infer<T>>> => {
+): Array<Either.Either.Right<ReadonlyArray.Infer<T>>> => {
   const out: Array<any> = []
   for (const a of self) {
-    if (E.isRight(a)) {
+    if (Either.isRight(a)) {
       out.push(a.right)
     }
   }
@@ -5071,11 +5075,10 @@ export const partition: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate: <T extends Iterable<Either<any, any>>>(
+export const separate: <T extends Iterable<Either.Either<any, any>>>(
   self: T
-) => [Array<Either.Left<ReadonlyArray.Infer<T>>>, Array<Either.Right<ReadonlyArray.Infer<T>>>] = partitionMap(
-  identity
-)
+) => [Array<Either.Either.Left<ReadonlyArray.Infer<T>>>, Array<Either.Either.Right<ReadonlyArray.Infer<T>>>] =
+  partitionMap(identity)
 
 /**
  * Reduces an array from the left.
@@ -5203,7 +5206,7 @@ export const reduceRight: {
  * @since 2.0.0
  */
 export const liftPredicate: { // Note: I intentionally avoid using the NoInfer pattern here.
-  <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Array<B>
+  <A, B extends A>(refinement: Predicate.Refinement<A, B>): (a: A) => Array<B>
   /**
    * Lifts a predicate into an array.
    *
@@ -5221,15 +5224,15 @@ export const liftPredicate: { // Note: I intentionally avoid using the NoInfer p
    * @category lifting
    * @since 2.0.0
    */
-  <A>(predicate: Predicate<A>): <B extends A>(b: B) => Array<B>
-} = <A>(predicate: Predicate<A>) => <B extends A>(b: B): Array<B> => predicate(b) ? [b] : []
+  <A>(predicate: Predicate.Predicate<A>): <B extends A>(b: B) => Array<B>
+} = <A>(predicate: Predicate.Predicate<A>) => <B extends A>(b: B): Array<B> => predicate(b) ? [b] : []
 
 /**
  * @category lifting
  * @since 2.0.0
  */
 export const liftOption = <A extends Array<unknown>, B>(
-  f: (...a: A) => Option<B>
+  f: (...a: A) => Option.Option<B>
 ) =>
 (...a: A): Array<B> => fromOption(f(...a))
 
@@ -5348,11 +5351,11 @@ export const flatMapNullable: {
  * @since 2.0.0
  */
 export const liftEither = <A extends Array<unknown>, E, B>(
-  f: (...a: A) => Either<B, E>
+  f: (...a: A) => Either.Either<B, E>
 ) =>
 (...a: A): Array<B> => {
   const e = f(...a)
-  return E.isLeft(e) ? [] : [e.right]
+  return Either.isLeft(e) ? [] : [e.right]
 }
 
 /**
@@ -5589,11 +5592,11 @@ export const max: {
  * @category constructors
  * @since 2.0.0
  */
-export const unfold = <B, A>(b: B, f: (b: B) => Option<readonly [A, B]>): Array<A> => {
+export const unfold = <B, A>(b: B, f: (b: B) => Option.Option<readonly [A, B]>): Array<A> => {
   const out: Array<A> = []
   let next: B = b
-  let o: Option<readonly [A, B]>
-  while (O.isSome(o = f(next))) {
+  let o: Option.Option<readonly [A, B]>
+  while (Option.isSome(o = f(next))) {
     const [a, b] = o.value
     out.push(a)
     next = b
@@ -5820,11 +5823,11 @@ export const dedupeAdjacentWith: {
   <A>(self: Iterable<A>, isEquivalent: (self: A, that: A) => boolean): Array<A>
 } = dual(2, <A>(self: Iterable<A>, isEquivalent: (self: A, that: A) => boolean): Array<A> => {
   const out: Array<A> = []
-  let lastA: O.Option<A> = O.none()
+  let lastA: Option.Option<A> = Option.none()
   for (const a of self) {
-    if (O.isNone(lastA) || !isEquivalent(a, lastA.value)) {
+    if (Option.isNone(lastA) || !isEquivalent(a, lastA.value)) {
       out.push(a)
-      lastA = O.some(a)
+      lastA = Option.some(a)
     }
   }
   return out
@@ -6277,7 +6280,7 @@ export const bind: {
     tag: Exclude<N, keyof A>,
     f: (a: NoInfer<A>) => ReadonlyArray<B>
   ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
-} = doNotation.bind<ReadonlyArrayTypeLambda>(map, flatMap) as any
+} = internalDoNotation.bind<ReadonlyArrayTypeLambda>(map, flatMap) as any
 
 /**
  * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
@@ -6423,7 +6426,7 @@ export const bindTo: {
    * @since 3.2.0
    */
   <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A }>
-} = doNotation.bindTo<ReadonlyArrayTypeLambda>(map) as any
+} = internalDoNotation.bindTo<ReadonlyArrayTypeLambda>(map) as any
 
 const let_: {
   <N extends string, B, A extends object>(
@@ -6435,7 +6438,7 @@ const let_: {
     tag: Exclude<N, keyof A>,
     f: (a: NoInfer<A>) => B
   ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
-} = doNotation.let_<ReadonlyArrayTypeLambda>(map) as any
+} = internalDoNotation.let_<ReadonlyArrayTypeLambda>(map) as any
 
 export {
   /**