effect 4.0.0-rc.118 → 4.0.1

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
 
 /**
@@ -13909,6 +13909,11 @@ export const onExitFilter: {
  * evaluations of the same effect will return the cached result without
  * re-executing the logic.
  *
+ * Concurrent callers share the pending computation, which is interrupted only
+ * once every caller waiting on it has been interrupted. Interrupted
+ * computations are never cached, so the next evaluation starts a fresh
+ * computation.
+ *
  * **Example** (Memoizing an effect until invalidated)
  *
  * ```ts import.meta.vitest
@@ -13970,11 +13975,12 @@ export const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
  * `Duration.Input`. The function runs once after each fresh computation,
  * including failures, so successes and failures can have different TTLs. It
  * does not run when the cache is created or when a cached result is reused.
- * The callback also receives interruption exits, which are cached for the
- * returned duration.
+ * Interrupted computations are never cached and do not call the function.
  *
  * The TTL starts when the computation completes. Concurrent callers share the
- * pending computation. A zero TTL expires immediately, and an infinite TTL
+ * pending computation, which is interrupted only once every caller waiting on
+ * it has been interrupted. The next evaluation then starts a fresh
+ * computation. A zero TTL expires immediately, and an infinite TTL
  * keeps the result indefinitely.
  *
  * **Example** (Memoizing an effect with TTL)
@@ -14054,11 +14060,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14138,11 +14145,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14222,11 +14230,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14306,11 +14315,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14371,8 +14381,8 @@ export const cachedWithTTL: {
 } = internal.cachedWithTTL
 
 /**
- * Creates a cached effect result for a specified duration and allows manual
- * invalidation before expiration.
+ * Creates a cached effect result for a fixed duration or a duration computed
+ * from its `Exit` and allows manual invalidation before expiration.
  *
  * **When to use**
  *
@@ -14430,8 +14440,67 @@ export const cachedWithTTL: {
  */
 export const cachedInvalidateWithTTL: {
   /**
-   * Creates a cached effect result for a specified duration and allows manual
-   * invalidation before expiration.
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
+   *
+   * **When to use**
+   *
+   * Use when an effect result should be cached for a bounded time and callers
+   * also need a manual invalidation effect to force recomputation before
+   * expiration.
+   *
+   * **Details**
+   *
+   * This function behaves similarly to {@link cachedWithTTL} by caching the
+   * result of an effect for a specified period of time. However, it introduces an
+   * additional feature: it provides an effect that allows you to manually
+   * invalidate the cached result before it naturally expires.
+   *
+   * This gives you more control over the cache, allowing you to refresh the
+   * result when needed, even if the original cache has not yet expired.
+   *
+   * Once the cache is invalidated, the next time the effect is evaluated, the
+   * result will be recomputed, and the cache will be refreshed.
+   *
+   * **Example** (Memoizing with TTL and invalidation)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect } from "effect"
+   * const output: Array<unknown> = []
+   * const record = (value: unknown) => Effect.sync(() => { output.push(value) })
+   *
+   * let i = 1
+   * const expensiveTask = Effect.sync(() => {
+   *   void output.push("expensive task...")
+   *   return `result ${i++}`
+   * })
+   *
+   * const program = Effect.gen(function*() {
+   *   const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(
+   *     expensiveTask,
+   *     "1 hour"
+   *   )
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* invalidate
+   *   yield* cached.pipe(Effect.andThen(record))
+   * })
+   *
+   * Effect.runSync(program)
+   * output // => ["expensive task...", "result 1", "result 1", "expensive task...", "result 2"]
+   * ```
+   *
+   * @see {@link cached} for a similar function that caches the result
+   * indefinitely.
+   * @see {@link cachedWithTTL} for a similar function that caches the result for
+   * a specified duration but does not include an effect for manual invalidation.
+   * @category caching
+   * @since 2.0.0
+   */
+  <A, E>(timeToLive: (exit: Exit.Exit<A, E>) => Duration.Input): <R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  /**
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
    *
    * **When to use**
    *
@@ -14489,8 +14558,67 @@ export const cachedInvalidateWithTTL: {
    */
   (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
   /**
-   * Creates a cached effect result for a specified duration and allows manual
-   * invalidation before expiration.
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
+   *
+   * **When to use**
+   *
+   * Use when an effect result should be cached for a bounded time and callers
+   * also need a manual invalidation effect to force recomputation before
+   * expiration.
+   *
+   * **Details**
+   *
+   * This function behaves similarly to {@link cachedWithTTL} by caching the
+   * result of an effect for a specified period of time. However, it introduces an
+   * additional feature: it provides an effect that allows you to manually
+   * invalidate the cached result before it naturally expires.
+   *
+   * This gives you more control over the cache, allowing you to refresh the
+   * result when needed, even if the original cache has not yet expired.
+   *
+   * Once the cache is invalidated, the next time the effect is evaluated, the
+   * result will be recomputed, and the cache will be refreshed.
+   *
+   * **Example** (Memoizing with TTL and invalidation)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect } from "effect"
+   * const output: Array<unknown> = []
+   * const record = (value: unknown) => Effect.sync(() => { output.push(value) })
+   *
+   * let i = 1
+   * const expensiveTask = Effect.sync(() => {
+   *   void output.push("expensive task...")
+   *   return `result ${i++}`
+   * })
+   *
+   * const program = Effect.gen(function*() {
+   *   const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(
+   *     expensiveTask,
+   *     "1 hour"
+   *   )
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* invalidate
+   *   yield* cached.pipe(Effect.andThen(record))
+   * })
+   *
+   * Effect.runSync(program)
+   * output // => ["expensive task...", "result 1", "result 1", "expensive task...", "result 2"]
+   * ```
+   *
+   * @see {@link cached} for a similar function that caches the result
+   * indefinitely.
+   * @see {@link cachedWithTTL} for a similar function that caches the result for
+   * a specified duration but does not include an effect for manual invalidation.
+   * @category caching
+   * @since 2.0.0
+   */
+  <A, E>(timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)): <R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  /**
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
    *
    * **When to use**
    *
@@ -14546,7 +14674,10 @@ export const cachedInvalidateWithTTL: {
    * @category caching
    * @since 2.0.0
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<[Effect<A, E, R>, Effect<void>]>
+  <A, E, R>(
+    self: Effect<A, E, R>,
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
+  ): Effect<[Effect<A, E, R>, Effect<void>]>
 } = internal.cachedInvalidateWithTTL
 
 // -----------------------------------------------------------------------------

package/src/HashRing.ts

@@ -179,12 +179,9 @@ export const addMany: {
         if (entry[1] === weight) continue
         toRemove ??= new Set()
         toRemove.add(key)
-        self.totalWeightCache -= entry[1]
-        self.totalWeightCache += weight
         entry[1] = weight
       } else {
         self.nodes.set(key, [node, weight])
-        self.totalWeightCache += weight
       }
       keys.push(key)
     }
@@ -192,6 +189,7 @@ export const addMany: {
       self.ring = self.ring.filter(([, n]) => !toRemove.has(n))
     }
     addNodesToRing(self, keys, Math.round(weight * self.baseWeight))
+    updateTotalWeight(self)
     return self
   }
 )
@@ -206,7 +204,18 @@ function addNodesToRing<A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, keys
       ])
     }
   }
-  self.ring.sort((a, b) => a[0] - b[0])
+  // Break hash ties by node key to avoid insertion-order dependence.
+  self.ring.sort((a, b) => a[0] - b[0] || (a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0))
+}
+
+// Sum in key order to avoid history-dependent floating-point rounding.
+function updateTotalWeight<A extends PrimaryKey.PrimaryKey>(self: HashRing<A>) {
+  const keys = Array.from(self.nodes.keys()).sort()
+  let total = 0
+  for (let i = 0; i < keys.length; i++) {
+    total += self.nodes.get(keys[i])![1]
+  }
+  self.totalWeightCache = total
 }
 
 /**
@@ -380,7 +389,7 @@ export const remove: {
   if (entry) {
     self.nodes.delete(key)
     self.ring = self.ring.filter(([, n]) => n !== key)
-    self.totalWeightCache -= entry[1]
+    updateTotalWeight(self)
   }
   return self
 })

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()]
 })
 
 /**