effect 4.0.0-rc.118 → 4.0.0

package/src/Array.ts

@@ -7770,7 +7770,7 @@ export const getSomes: <T extends Iterable<Option.Option<X>>, X = any>(
  * ```
  *
  * @see {@link getSuccesses} — extract success values
- * @see {@link separate} — split into failures and successes
+ * @see {@link separate} — split into successes and failures
  *
  * @category filtering
  * @since 4.0.0
@@ -7806,7 +7806,7 @@ export const getFailures = <T extends Iterable<Result.Result<any, any>>>(
  * ```
  *
  * @see {@link getFailures} — extract failure values
- * @see {@link separate} — split into failures and successes
+ * @see {@link separate} — split into successes and failures
  *
  * @category filtering
  * @since 4.0.0
@@ -7845,7 +7845,7 @@ export const getSuccesses = <T extends Iterable<Result.Result<any, any>>>(
  * ```
  *
  * @see {@link filter} — keep original elements matching a predicate
- * @see {@link partition} for keeping both failures and successes
+ * @see {@link partition} for keeping both successes and failures
  *
  * @category filtering
  * @since 2.0.0
@@ -7872,7 +7872,7 @@ export const filterMap: {
    * ```
    *
    * @see {@link filter} — keep original elements matching a predicate
-   * @see {@link partition} for keeping both failures and successes
+   * @see {@link partition} for keeping both successes and failures
    *
    * @category filtering
    * @since 2.0.0
@@ -7899,7 +7899,7 @@ export const filterMap: {
    * ```
    *
    * @see {@link filter} — keep original elements matching a predicate
-   * @see {@link partition} for keeping both failures and successes
+   * @see {@link partition} for keeping both successes and failures
    *
    * @category filtering
    * @since 2.0.0
@@ -8072,16 +8072,16 @@ export const filter: {
 )
 
 /**
- * Splits an iterable using a `Filter` into failures and successes.
+ * Splits an iterable using a `Filter` into successes and failures.
  *
  * **When to use**
  *
  * Use to partition an iterable by evaluating each element with a
- * `Result`-returning filter and keeping both failure and success values.
+ * `Result`-returning filter and keeping both success and failure values.
  *
  * **Details**
  *
- * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+ * Returns `[passes, fails]`. The filter receives `(element, index)`.
  *
  * **Example** (Partitioning with a filter)
  *
@@ -8090,7 +8090,7 @@ export const filter: {
  *
  * Array.partition([1, -2, 3], (n, i) =>
  *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
- * ) // => [["negative:-2"], [1, 5]]
+ * ) // => [[1, 5], ["negative:-2"]]
  * ```
  *
  * @see {@link filter} — keep only matching elements
@@ -8102,16 +8102,16 @@ export const filter: {
  */
 export const partition: {
   /**
-   * Splits an iterable using a `Filter` into failures and successes.
+   * Splits an iterable using a `Filter` into successes and failures.
    *
    * **When to use**
    *
    * Use to partition an iterable by evaluating each element with a
-   * `Result`-returning filter and keeping both failure and success values.
+   * `Result`-returning filter and keeping both success and failure values.
    *
    * **Details**
    *
-   * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+   * Returns `[passes, fails]`. The filter receives `(element, index)`.
    *
    * **Example** (Partitioning with a filter)
    *
@@ -8120,7 +8120,7 @@ export const partition: {
    *
    * Array.partition([1, -2, 3], (n, i) =>
    *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
-   * ) // => [["negative:-2"], [1, 5]]
+   * ) // => [[1, 5], ["negative:-2"]]
    * ```
    *
    * @see {@link filter} — keep only matching elements
@@ -8130,18 +8130,18 @@ export const partition: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result.Result<Pass, Fail>): (self: Iterable<A>) => [excluded: Array<Fail>, satisfying: Array<Pass>]
+  <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result.Result<Pass, Fail>): (self: Iterable<A>) => [passes: Array<Pass>, fails: Array<Fail>]
   /**
-   * Splits an iterable using a `Filter` into failures and successes.
+   * Splits an iterable using a `Filter` into successes and failures.
    *
    * **When to use**
    *
    * Use to partition an iterable by evaluating each element with a
-   * `Result`-returning filter and keeping both failure and success values.
+   * `Result`-returning filter and keeping both success and failure values.
    *
    * **Details**
    *
-   * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+   * Returns `[passes, fails]`. The filter receives `(element, index)`.
    *
    * **Example** (Partitioning with a filter)
    *
@@ -8150,7 +8150,7 @@ export const partition: {
    *
    * Array.partition([1, -2, 3], (n, i) =>
    *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
-   * ) // => [["negative:-2"], [1, 5]]
+   * ) // => [[1, 5], ["negative:-2"]]
    * ```
    *
    * @see {@link filter} — keep only matching elements
@@ -8160,38 +8160,38 @@ export const partition: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, Pass, Fail>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<Pass, Fail>): [excluded: Array<Fail>, satisfying: Array<Pass>]
+  <A, Pass, Fail>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<Pass, Fail>): [passes: Array<Pass>, fails: Array<Fail>]
 } = dual(
   2,
   <A, Pass, Fail>(
     self: Iterable<A>,
     f: (input: A, i: number) => Result.Result<Pass, Fail>
-  ): [excluded: Array<Fail>, satisfying: Array<Pass>] => {
-    const excluded: Array<Fail> = []
-    const satisfying: Array<Pass> = []
+  ): [passes: Array<Pass>, fails: Array<Fail>] => {
+    const passes: Array<Pass> = []
+    const fails: Array<Fail> = []
     let i = 0
     for (const a of self) {
       const result = f(a, i++)
       if (Result.isSuccess(result)) {
-        satisfying.push(result.success)
+        passes.push(result.success)
       } else {
-        excluded.push(result.failure)
+        fails.push(result.failure)
       }
     }
-    return [excluded, satisfying]
+    return [passes, fails]
   }
 )
 
 /**
- * Separates an iterable of `Result`s into failure values and success values.
+ * Separates an iterable of `Result`s into success values and failure values.
  *
  * **When to use**
  *
- * Use to split an iterable of `Result` values into failure and success arrays.
+ * Use to split an iterable of `Result` values into success and failure arrays.
  *
  * **Details**
  *
- * Returns `[failures, successes]`. This is equivalent to
+ * Returns `[successes, failures]`. This is equivalent to
  * `partition(identity)`.
  *
  * **Example** (Separating Results)
@@ -8199,7 +8199,7 @@ export const partition: {
  * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * Array.separate([Result.succeed(1), Result.fail("error"), Result.succeed(2)]) // => [["error"], [1, 2]]
+ * Array.separate([Result.succeed(1), Result.fail("error"), Result.succeed(2)]) // => [[1, 2], ["error"]]
  * ```
  *
  * @see {@link getFailures} — extract only failures
@@ -8212,8 +8212,8 @@ export const partition: {
 export const separate: <T extends Iterable<Result.Result<any, any>>>(
   self: T
 ) => [
-  failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>,
-  successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>
+  successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>,
+  failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>
 ] = partition(identity)
 
 /**

package/src/Chunk.ts

@@ -2854,23 +2854,23 @@ export const mapAccum: {
 })
 
 /**
- * Splits a chunk using a `Filter` into failures and successes.
+ * Splits a chunk using a `Filter` into successes and failures.
  *
  * **Details**
  *
- * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+ * Returns `[passes, fails]`. The filter receives `(element, index)`.
  *
  * **Example** (Partitioning with a Result)
  *
  * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
- * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+ * const [passes, fails] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
  *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
  * )
  *
- * Chunk.toArray(excluded) // => ["negative:-2"]
- * Chunk.toArray(satisfying) // => [1, 5]
+ * Chunk.toArray(passes) // => [1, 5]
+ * Chunk.toArray(fails) // => ["negative:-2"]
  * ```
  *
  * @category filtering
@@ -2878,74 +2878,74 @@ export const mapAccum: {
  */
 export const partition: {
   /**
-   * Splits a chunk using a `Filter` into failures and successes.
+   * Splits a chunk using a `Filter` into successes and failures.
    *
    * **Details**
    *
-   * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+   * Returns `[passes, fails]`. The filter receives `(element, index)`.
    *
    * **Example** (Partitioning with a Result)
    *
    * ```ts import.meta.vitest
    * import { Chunk, Result } from "effect"
    *
-   * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+   * const [passes, fails] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
    *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
    * )
    *
-   * Chunk.toArray(excluded) // => ["negative:-2"]
-   * Chunk.toArray(satisfying) // => [1, 5]
+   * Chunk.toArray(passes) // => [1, 5]
+   * Chunk.toArray(fails) // => ["negative:-2"]
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result<Pass, Fail>): (self: Chunk<A>) => [excluded: Chunk<Fail>, satisfying: Chunk<Pass>]
+  <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result<Pass, Fail>): (self: Chunk<A>) => [passes: Chunk<Pass>, fails: Chunk<Fail>]
   /**
-   * Splits a chunk using a `Filter` into failures and successes.
+   * Splits a chunk using a `Filter` into successes and failures.
    *
    * **Details**
    *
-   * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.
+   * Returns `[passes, fails]`. The filter receives `(element, index)`.
    *
    * **Example** (Partitioning with a Result)
    *
    * ```ts import.meta.vitest
    * import { Chunk, Result } from "effect"
    *
-   * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+   * const [passes, fails] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
    *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
    * )
    *
-   * Chunk.toArray(excluded) // => ["negative:-2"]
-   * Chunk.toArray(satisfying) // => [1, 5]
+   * Chunk.toArray(passes) // => [1, 5]
+   * Chunk.toArray(fails) // => ["negative:-2"]
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <A, Pass, Fail>(self: Chunk<A>, f: (input: A, i: number) => Result<Pass, Fail>): [excluded: Chunk<Fail>, satisfying: Chunk<Pass>]
+  <A, Pass, Fail>(self: Chunk<A>, f: (input: A, i: number) => Result<Pass, Fail>): [passes: Chunk<Pass>, fails: Chunk<Fail>]
 } = dual(
   2,
   <A, Pass, Fail>(
     self: Chunk<A>,
     f: (input: A, i: number) => Result<Pass, Fail>
-  ): [excluded: Chunk<Fail>, satisfying: Chunk<Pass>] => {
-    const [excluded, satisfying] = RA.partition(self, f)
-    return [fromArrayUnsafe(excluded), fromArrayUnsafe(satisfying)]
+  ): [passes: Chunk<Pass>, fails: Chunk<Fail>] => {
+    const [passes, fails] = RA.partition(self, f)
+    return [fromArrayUnsafe(passes), fromArrayUnsafe(fails)]
   }
 )
 
 /**
- * Separates a chunk of `Result` values into a chunk of failures and a chunk of
- * successes.
+ * Separates a chunk of `Result` values into a chunk of successes and a chunk of
+ * failures.
  *
  * **Details**
  *
- * The returned tuple is `[failures, successes]`, preserving the original order
+ * The returned tuple is `[successes, failures]`, preserving the original order
  * within each side.
  *
- * **Example** (Separating failures and successes)
+ * **Example** (Separating successes and failures)
  *
  * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
@@ -2958,21 +2958,21 @@ export const partition: {
  *   Result.succeed(3)
  * )
  *
- * const [errors, values] = Chunk.separate(chunk)
- * Chunk.toArray(errors) // => ["error1", "error2"]
+ * const [values, errors] = Chunk.separate(chunk)
  * Chunk.toArray(values) // => [1, 2, 3]
+ * Chunk.toArray(errors) // => ["error1", "error2"]
  *
  * // All successes
  * const allSuccesses = Chunk.make(Result.succeed(1), Result.succeed(2))
- * const [noErrors, allValues] = Chunk.separate(allSuccesses)
- * Chunk.toArray(noErrors) // => []
+ * const [allValues, noErrors] = Chunk.separate(allSuccesses)
  * Chunk.toArray(allValues) // => [1, 2]
+ * Chunk.toArray(noErrors) // => []
  * ```
  *
  * @category filtering
  * @since 2.0.0
  */
-export const separate = <A, B>(self: Chunk<Result<B, A>>): [Chunk<A>, Chunk<B>] =>
+export const separate = <A, B>(self: Chunk<Result<B, A>>): [Chunk<B>, Chunk<A>] =>
   pipe(
     RA.separate(toReadonlyArray(self)),
     ([l, r]) => [fromArrayUnsafe(l), fromArrayUnsafe(r)]

package/src/Effect.ts

@@ -503,13 +503,13 @@ export const all: <
 ) => All.Return<Arg, O> = internal.all
 
 /**
- * Applies an effectful function to each element and partitions failures and
- * successes.
+ * Applies an effectful function to each element and partitions successes and
+ * failures.
  *
  * **Details**
  *
- * The returned tuple is `[excluded, satisfying]`, where `excluded` contains
- * all failures and `satisfying` contains all successes.
+ * The returned tuple is `[passes, fails]`, where `passes` contains all
+ * successes and `fails` contains all failures.
  *
  * This function runs every effect and never fails. Use `concurrency` to control
  * parallelism.
@@ -523,7 +523,7 @@ export const all: <
  *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
  * )
  *
- * await Effect.runPromise(program) // => [['0 is even', '2 is even'], [1, 3]]
+ * await Effect.runPromise(program) // => [[1, 3], ['0 is even', '2 is even']]
  * ```
  *
  * @category collecting
@@ -531,13 +531,13 @@ export const all: <
  */
 export const partition: {
   /**
-   * Applies an effectful function to each element and partitions failures and
-   * successes.
+   * Applies an effectful function to each element and partitions successes and
+   * failures.
    *
    * **Details**
    *
-   * The returned tuple is `[excluded, satisfying]`, where `excluded` contains
-   * all failures and `satisfying` contains all successes.
+   * The returned tuple is `[passes, fails]`, where `passes` contains all
+   * successes and `fails` contains all failures.
    *
    * This function runs every effect and never fails. Use `concurrency` to control
    * parallelism.
@@ -551,7 +551,7 @@ export const partition: {
    *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
    * )
    *
-   * await Effect.runPromise(program) // => [['0 is even', '2 is even'], [1, 3]]
+   * await Effect.runPromise(program) // => [[1, 3], ['0 is even', '2 is even']]
    * ```
    *
    * @category collecting
@@ -560,15 +560,15 @@ export const partition: {
   <A, B, E, R>(
     f: (a: A, i: number) => Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): (elements: Iterable<A>) => Effect<[passes: Array<B>, fails: Array<E>], never, R>
   /**
-   * Applies an effectful function to each element and partitions failures and
-   * successes.
+   * Applies an effectful function to each element and partitions successes and
+   * failures.
    *
    * **Details**
    *
-   * The returned tuple is `[excluded, satisfying]`, where `excluded` contains
-   * all failures and `satisfying` contains all successes.
+   * The returned tuple is `[passes, fails]`, where `passes` contains all
+   * successes and `fails` contains all failures.
    *
    * This function runs every effect and never fails. Use `concurrency` to control
    * parallelism.
@@ -582,7 +582,7 @@ export const partition: {
    *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
    * )
    *
-   * await Effect.runPromise(program) // => [['0 is even', '2 is even'], [1, 3]]
+   * await Effect.runPromise(program) // => [[1, 3], ['0 is even', '2 is even']]
    * ```
    *
    * @category collecting
@@ -592,7 +592,7 @@ export const partition: {
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): Effect<[passes: Array<B>, fails: Array<E>], never, R>
 } = internal.partition
 
 /**

package/src/MutableHashMap.ts

@@ -397,10 +397,6 @@ export const get: {
   } else if (isSimpleKey(key)) {
     return Option.none()
   }
-  const refKey = referentialKeysCache.get(key)
-  if (refKey !== undefined && self.backing.has(refKey)) {
-    return Option.some(self.backing.get(refKey)!)
-  }
   const hash = Hash.hash(key)
   const bucket = self.buckets.get(hash)
   if (bucket === undefined) {
@@ -409,7 +405,6 @@ export const get: {
   return getFromBucket(self, bucket, key)
 })
 
-const referentialKeysCache = new WeakMap<any, any>()
 const isSimpleKey = (u: unknown): boolean => typeof u !== "object" && typeof u !== "function"
 
 /**
@@ -483,7 +478,6 @@ const getFromBucket = <K, V>(
   for (let i = 0, len = bucket.length; i < len; i++) {
     if (Equal.equals(key, bucket[i])) {
       const refKey = bucket[i]
-      referentialKeysCache.set(key, refKey)
       return Option.some(self.backing.get(refKey)!)
     }
   }
@@ -839,12 +833,6 @@ export const set: {
     self.backing.set(key, value)
     return self
   }
-  let refKey = referentialKeysCache.get(key)
-  if (refKey !== undefined && self.backing.has(refKey)) {
-    self.backing.set(refKey, value)
-    return self
-  }
-
   const hash = Hash.hash(key)
   const bucket = self.buckets.get(hash)
   if (bucket === undefined) {
@@ -853,7 +841,7 @@ export const set: {
     return self
   }
 
-  refKey = getRefKey(bucket, key)
+  let refKey = getRefKey(bucket, key)
   if (refKey === undefined) {
     bucket.push(key)
     refKey = key
@@ -868,7 +856,6 @@ const getRefKey = <K>(
 ) => {
   for (let i = 0, len = bucket.length; i < len; i++) {
     if (Equal.equals(key, bucket[i])) {
-      referentialKeysCache.set(key, bucket[i])
       return bucket[i]
     }
   }
@@ -1083,19 +1070,13 @@ export const modify: {
     }
     return self
   }
-  let refKey = referentialKeysCache.get(key)
-  if (refKey !== undefined && self.backing.has(refKey)) {
-    self.backing.set(refKey, f(self.backing.get(refKey)!))
-    return self
-  }
-
   const hash = Hash.hash(key)
   const bucket = self.buckets.get(hash)
   if (bucket === undefined) {
     return self
   }
 
-  refKey = getRefKey(bucket, key)
+  const refKey = getRefKey(bucket, key)
   if (refKey === undefined) {
     return self
   }
@@ -1607,15 +1588,14 @@ export const remove: {
     return self
   }
 
-  const key = referentialKeysCache.get(key_) ?? key_
-  const hash = Hash.hash(key)
+  const hash = Hash.hash(key_)
   const bucket = self.buckets.get(hash)
   if (bucket === undefined) {
     return self
   }
   for (let i = 0, len = bucket.length; i < len; i++) {
     const bkey = bucket[i]
-    if (bkey === key || Equal.equals(key, bkey)) {
+    if (bkey === key_ || Equal.equals(key_, bkey)) {
       self.backing.delete(bkey)
       bucket.splice(i, 1)
       break

package/src/Option.ts

@@ -3185,14 +3185,14 @@ export const toArray = <A>(self: Option<A>): Array<A> => isNone(self) ? [] : [se
  *
  * **When to use**
  *
- * Use when you need to split an optional value into "left" and "right"
+ * Use when you need to split an optional value into success and failure
  * channels using a `Result`-returning function.
  *
  * **Details**
  *
  * - `None` → `[None, None]`
- * - `Some` where `f` returns `Err` → `[Some(error), None]`
- * - `Some` where `f` returns `Ok` → `[None, Some(value)]`
+ * - `Some` where `f` returns `Ok` → `[Some(value), None]`
+ * - `Some` where `f` returns `Err` → `[None, Some(error)]`
  *
  * **Example** (Partitioning by Result)
  *
@@ -3204,8 +3204,8 @@ export const toArray = <A>(self: Option<A>): Array<A> => isNone(self) ? [] : [se
  *   return isNaN(n) ? Result.fail("Not a number") : Result.succeed(n)
  * }
  *
- * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.none(), Option.some(42)]
- * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.some("Not a number"), Option.none()]
+ * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.some(42), Option.none()]
+ * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.none(), Option.some("Not a number")]
  * Option.partitionMap(Option.none(), parseNumber) // => [Option.none(), Option.none()]
  * ```
  *
@@ -3220,14 +3220,14 @@ export const partitionMap: {
    *
    * **When to use**
    *
-   * Use when you need to split an optional value into "left" and "right"
+   * Use when you need to split an optional value into success and failure
    * channels using a `Result`-returning function.
    *
    * **Details**
    *
    * - `None` → `[None, None]`
-   * - `Some` where `f` returns `Err` → `[Some(error), None]`
-   * - `Some` where `f` returns `Ok` → `[None, Some(value)]`
+   * - `Some` where `f` returns `Ok` → `[Some(value), None]`
+   * - `Some` where `f` returns `Err` → `[None, Some(error)]`
    *
    * **Example** (Partitioning by Result)
    *
@@ -3239,8 +3239,8 @@ export const partitionMap: {
    *   return isNaN(n) ? Result.fail("Not a number") : Result.succeed(n)
    * }
    *
-   * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.none(), Option.some(42)]
-   * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.some("Not a number"), Option.none()]
+   * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.some(42), Option.none()]
+   * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.none(), Option.some("Not a number")]
    * Option.partitionMap(Option.none(), parseNumber) // => [Option.none(), Option.none()]
    * ```
    *
@@ -3249,20 +3249,20 @@ export const partitionMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, C>(f: (a: A) => Result<C, B>): (self: Option<A>) => [left: Option<B>, right: Option<C>]
+  <A, B, C>(f: (a: A) => Result<C, B>): (self: Option<A>) => [passes: Option<C>, fails: Option<B>]
   /**
    * Splits an `Option` into two `Option`s using a function that returns a `Result`.
    *
    * **When to use**
    *
-   * Use when you need to split an optional value into "left" and "right"
+   * Use when you need to split an optional value into success and failure
    * channels using a `Result`-returning function.
    *
    * **Details**
    *
    * - `None` → `[None, None]`
-   * - `Some` where `f` returns `Err` → `[Some(error), None]`
-   * - `Some` where `f` returns `Ok` → `[None, Some(value)]`
+   * - `Some` where `f` returns `Ok` → `[Some(value), None]`
+   * - `Some` where `f` returns `Err` → `[None, Some(error)]`
    *
    * **Example** (Partitioning by Result)
    *
@@ -3274,8 +3274,8 @@ export const partitionMap: {
    *   return isNaN(n) ? Result.fail("Not a number") : Result.succeed(n)
    * }
    *
-   * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.none(), Option.some(42)]
-   * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.some("Not a number"), Option.none()]
+   * Option.partitionMap(Option.some("42"), parseNumber) // => [Option.some(42), Option.none()]
+   * Option.partitionMap(Option.some("abc"), parseNumber) // => [Option.none(), Option.some("Not a number")]
    * Option.partitionMap(Option.none(), parseNumber) // => [Option.none(), Option.none()]
    * ```
    *
@@ -3284,16 +3284,16 @@ export const partitionMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, C>(self: Option<A>, f: (a: A) => Result<C, B>): [left: Option<B>, right: Option<C>]
+  <A, B, C>(self: Option<A>, f: (a: A) => Result<C, B>): [passes: Option<C>, fails: Option<B>]
 } = dual(2, <A, B, C>(
   self: Option<A>,
   f: (a: A) => Result<C, B>
-): [excluded: Option<B>, satisfying: Option<C>] => {
+): [passes: Option<C>, fails: Option<B>] => {
   if (isNone(self)) {
     return [none(), none()]
   }
   const e = f(self.value)
-  return result.isFailure(e) ? [some(e.failure), none()] : [none(), some(e.success)]
+  return result.isFailure(e) ? [none(), some(e.failure)] : [some(e.success), none()]
 })
 
 /**