effect 4.0.5 → 4.0.6

package/src/Equivalence.ts

@@ -462,7 +462,8 @@ export const combine: {
  * comparison stops at the first equivalence that returns `false`. Empty
  * collections return an equivalence that always returns `true`. The result is
  * also an equivalence that satisfies reflexive, symmetric, and transitive
- * properties.
+ * properties. The collection is materialized when the equivalence is created,
+ * so it must be finite.
  *
  * **Example** (Combining multiple field equivalences)
  *
@@ -514,15 +515,17 @@ export const combine: {
  * @category combining
  * @since 2.0.0
  */
-export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> =>
-  make((x, y) => {
-    for (const equivalence of collection) {
+export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> => {
+  const equivalences = Array.from(collection)
+  return make((x, y) => {
+    for (const equivalence of equivalences) {
       if (!equivalence(x, y)) {
         return false
       }
     }
     return true
   })
+}
 
 /**
  * Transforms an equivalence relation by mapping the input values before comparison.

package/src/Exit.ts

@@ -953,8 +953,10 @@ export const map: {
  *
  * **Gotchas**
  *
- * Only transforms typed errors (Fail reasons). If the Cause contains only
- * defects or interruptions, the failure passes through unchanged.
+ * Maps every typed error in the cause, preserving defects, interrupts and
+ * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+ *
+ * If the Cause contains only defects or interruptions, no mapper is called.
  *
  * **Example** (Mapping over an error)
  *
@@ -987,8 +989,10 @@ export const mapError: {
    *
    * **Gotchas**
    *
-   * Only transforms typed errors (Fail reasons). If the Cause contains only
-   * defects or interruptions, the failure passes through unchanged.
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
+   * If the Cause contains only defects or interruptions, no mapper is called.
    *
    * **Example** (Mapping over an error)
    *
@@ -1021,8 +1025,10 @@ export const mapError: {
    *
    * **Gotchas**
    *
-   * Only transforms typed errors (Fail reasons). If the Cause contains only
-   * defects or interruptions, the failure passes through unchanged.
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
+   * If the Cause contains only defects or interruptions, no mapper is called.
    *
    * **Example** (Mapping over an error)
    *
@@ -1052,11 +1058,14 @@ export const mapError: {
  * **Details**
  *
  * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
- * transforms the typed error if the Exit is a Failure with a Fail reason.
+ * transforms each typed error if the Exit is a Failure with Fail reasons.
  * Allocates a new Exit.
  *
  * **Gotchas**
  *
+ * Maps every typed error in the cause, preserving defects, interrupts and
+ * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+ *
  * If the Cause contains only defects or interruptions, the failure passes
  * through unchanged.
  *
@@ -1089,11 +1098,14 @@ export const mapBoth: {
    * **Details**
    *
    * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
-   * transforms the typed error if the Exit is a Failure with a Fail reason.
+   * transforms each typed error if the Exit is a Failure with Fail reasons.
    * Allocates a new Exit.
    *
    * **Gotchas**
    *
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
    * If the Cause contains only defects or interruptions, the failure passes
    * through unchanged.
    *
@@ -1128,11 +1140,14 @@ export const mapBoth: {
    * **Details**
    *
    * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
-   * transforms the typed error if the Exit is a Failure with a Fail reason.
+   * transforms each typed error if the Exit is a Failure with Fail reasons.
    * Allocates a new Exit.
    *
    * **Gotchas**
    *
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
    * If the Cause contains only defects or interruptions, the failure passes
    * through unchanged.
    *

package/src/FiberHandle.ts

@@ -62,6 +62,8 @@ export interface FiberHandle<out A = unknown, out E = unknown> extends Pipeable,
   state: {
     readonly _tag: "Open"
     fiber: Fiber.Fiber<A, E> | undefined
+    /** Every fiber the handle still owns: the current one plus replaced fibers that are still interrupting. */
+    readonly fibers: Set<Fiber.Fiber<A, E>>
   } | {
     readonly _tag: "Closed"
   }
@@ -105,7 +107,7 @@ const Proto = {
 
 const makeUnsafe = <A = unknown, E = unknown>(): FiberHandle<A, E> => {
   const self = Object.create(Proto)
-  self.state = { _tag: "Open", fiber: undefined }
+  self.state = { _tag: "Open", fiber: undefined, fibers: new Set() }
   self.deferred = Deferred.makeUnsafe()
   return self
 }
@@ -154,12 +156,7 @@ export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberHandle<A, E
       const state = handle.state
       if (state._tag === "Closed") return Effect.void
       handle.state = { _tag: "Closed" }
-      return state.fiber ?
-        Deferred.into(
-          Effect.asVoid(Fiber.interruptAs(state.fiber, internalFiberId)),
-          handle.deferred
-        ) :
-        Deferred.done(handle.deferred, Exit.void)
+      return Deferred.into(Fiber.interruptAllAs(state.fibers, internalFiberId), handle.deferred)
     }
   )
 
@@ -418,10 +415,14 @@ export const setUnsafe: {
 
   // Install the replacement before interruption can re-enter the handle through a finalizer.
   self.state.fiber = fiber
+  self.state.fibers.add(fiber)
   previous?.interruptUnsafe(internalFiberId)
   fiber.addObserver((exit) => {
-    if (self.state._tag === "Open" && fiber === self.state.fiber) {
-      self.state.fiber = undefined
+    if (self.state._tag === "Open") {
+      self.state.fibers.delete(fiber)
+      if (fiber === self.state.fiber) {
+        self.state.fiber = undefined
+      }
     }
     if (
       Exit.isFailure(exit) &&

package/src/FiberMap.ts

@@ -67,6 +67,8 @@ export interface FiberMap<in out K, out A = unknown, out E = unknown>
   state: {
     readonly _tag: "Open"
     readonly backing: MutableHashMap.MutableHashMap<K, Fiber.Fiber<A, E>>
+    /** Every fiber the map still owns: the keyed ones plus replaced fibers that are still interrupting. */
+    readonly fibers: Set<Fiber.Fiber<A, E>>
   } | {
     readonly _tag: "Closed"
   }
@@ -122,7 +124,7 @@ const makeUnsafe = <K, A = unknown, E = unknown>(
   deferred: Deferred.Deferred<void, E>
 ): FiberMap<K, A, E> => {
   const self = Object.create(Proto)
-  self.state = { _tag: "Open", backing }
+  self.state = { _tag: "Open", backing, fibers: new Set() }
   self.deferred = deferred
   return self
 }
@@ -176,7 +178,7 @@ export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A
         const state = map.state
         if (state._tag === "Closed") return Effect.void
         map.state = { _tag: "Closed" }
-        return Fiber.interruptAll(MutableHashMap.values(state.backing)).pipe(
+        return Fiber.interruptAll(state.fibers).pipe(
           Deferred.into(map.deferred)
         )
       })
@@ -471,6 +473,7 @@ export const setUnsafe: {
 
   // Install the replacement before interruption can re-enter the map through a finalizer.
   MutableHashMap.set(self.state.backing, key, fiber)
+  self.state.fibers.add(fiber)
   if (previous._tag === "Some") {
     previous.value.interruptUnsafe(internalFiberId)
   }
@@ -478,6 +481,7 @@ export const setUnsafe: {
     if (self.state._tag === "Closed") {
       return
     }
+    self.state.fibers.delete(fiber)
     const current = MutableHashMap.get(self.state.backing, key)
     if (Option.isSome(current) && fiber === current.value) {
       MutableHashMap.remove(self.state.backing, key)
@@ -1145,70 +1149,13 @@ export const remove: {
    */
   <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<void>
 } = dual<
-  /**
-   * Removes a fiber from the FiberMap, interrupting it if it exists.
-   *
-   * **Example** (Removing a fiber)
-   *
-   * ```ts import.meta.vitest
-   * import { Effect, FiberMap } from "effect"
-   *
-   * const program = Effect.gen(function*() {
-   *   const map = yield* FiberMap.make<string>()
-   *
-   *   // Add some fibers to the map
-   *   yield* FiberMap.run(map, "task1", Effect.never)
-   *   yield* FiberMap.run(map, "task2", Effect.never)
-   *
-   *   const sizeBefore = yield* FiberMap.size(map)
-   *
-   *   // Remove a specific fiber (this will interrupt it)
-   *   yield* FiberMap.remove(map, "task1")
-   *
-   *   return [sizeBefore, yield* FiberMap.size(map)]
-   * })
-   *
-   * const actual = await Effect.runPromise(Effect.scoped(program))
-   * actual // => [2, 1]
-   * ```
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  <K>(key: K) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
-  /**
-   * Removes a fiber from the FiberMap, interrupting it if it exists.
-   *
-   * **Example** (Removing a fiber)
-   *
-   * ```ts import.meta.vitest
-   * import { Effect, FiberMap } from "effect"
-   *
-   * const program = Effect.gen(function*() {
-   *   const map = yield* FiberMap.make<string>()
-   *
-   *   // Add some fibers to the map
-   *   yield* FiberMap.run(map, "task1", Effect.never)
-   *   yield* FiberMap.run(map, "task2", Effect.never)
-   *
-   *   const sizeBefore = yield* FiberMap.size(map)
-   *
-   *   // Remove a specific fiber (this will interrupt it)
-   *   yield* FiberMap.remove(map, "task1")
-   *
-   *   return [sizeBefore, yield* FiberMap.size(map)]
-   * })
-   *
-   * const actual = await Effect.runPromise(Effect.scoped(program))
-   * actual // => [2, 1]
-   * ```
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K) => Effect.Effect<void>
+  <K>(
+    key: K
+  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
+    key: K
+  ) => Effect.Effect<void>
 >(2, (self, key) =>
   Effect.suspend(() => {
     if (self.state._tag === "Closed") {

package/src/FileSystem.ts

@@ -152,6 +152,13 @@ export interface FileSystem {
     fromPath: string,
     toPath: string
   ) => Effect.Effect<void, PlatformError>
+  /**
+   * Get information about a file at `path` without following symbolic links.
+   * See `File.Info` for metadata limits.
+   */
+  readonly lstat: (
+    path: string
+  ) => Effect.Effect<File.Info, PlatformError>
   /**
    * Create a directory at `path`. You can optionally specify the mode and
    * whether to recursively create nested directories.
@@ -671,6 +678,9 @@ export const makeNoop = (fileSystem: Partial<FileSystem>): FileSystem =>
     link(path) {
       return Effect.fail(notFound("link", path))
     },
+    lstat(path) {
+      return Effect.fail(notFound("lstat", path))
+    },
     makeDirectory() {
       return Effect.die("not implemented")
     },