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

package/src/Cache.ts

@@ -637,7 +637,10 @@ export const get: {
           MutableHashMap.remove(self.map, key)
         }
       })
-      MutableHashMap.set(self.map, key, entry)
+      const exit = entry.fiber.pollUnsafe()
+      if (exit === undefined || !effect.exitHasInterrupts(exit)) {
+        MutableHashMap.set(self.map, key, entry)
+      }
       if (Number.isFinite(self.capacity)) {
         checkCapacity(self)
       }
@@ -2109,6 +2112,10 @@ export const invalidateWhen: {
       return oentry.await().pipe(
         effect.map((value) => {
           if (f(value)) {
+            const current = MutableHashMap.get(self.map, key)
+            if (Option.isNone(current) || current.value !== oentry) {
+              return false
+            }
             MutableHashMap.remove(self.map, key)
             return true
           }
@@ -2431,12 +2438,18 @@ export const refresh: {
       }
       entry.fiber.addObserver((exit) => {
         if (effect.exitHasInterrupts(exit)) {
-          if (!existing) MutableHashMap.remove(self.map, key)
+          const current = MutableHashMap.get(self.map, key)
+          if (Option.isSome(current) && current.value === entry) {
+            MutableHashMap.remove(self.map, key)
+          }
           return
         }
         const ttl = self.timeToLive(exit, key)
         if (Duration.isZero(ttl)) {
-          MutableHashMap.remove(self.map, key)
+          const current = MutableHashMap.get(self.map, key)
+          if (existing || (Option.isSome(current) && current.value === entry)) {
+            MutableHashMap.remove(self.map, key)
+          }
           return effect.void
         }
         entry.expiresAt = Duration.isFinite(ttl)
@@ -2444,6 +2457,7 @@ export const refresh: {
           : undefined
         if (existing) {
           MutableHashMap.set(self.map, key, entry)
+          checkCapacity(self)
         }
       })
       return entry.await()

package/src/Cause.ts

@@ -261,7 +261,7 @@ export declare namespace Cause {
     readonly [ReasonTypeId]: typeof ReasonTypeId
     readonly _tag: Tag
     readonly annotations: ReadonlyMap<string, unknown>
-    annotate(annotations: Context.Context<never> | ReadonlyMap<string, unknown>, options?: {
+    annotate(annotations: Context.Context<never>, options?: {
       readonly overwrite?: boolean | undefined
     }): this
   }

package/src/Channel.ts

@@ -20,6 +20,7 @@ import * as Fiber from "./Fiber.ts"
 import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constTrue, constVoid, dual, identity as identity_ } from "./Function.ts"
+import * as Count from "./internal/count.ts"
 import { ClockRef, endSpan, scopeFinalizerCountUnsafe } from "./internal/effect.ts"
 import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
@@ -758,6 +759,11 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Channel<A> => fromArray(Chu
 /**
  * Creates a `Channel` from an iterator that emits arrays of elements.
  *
+ * **Details**
+ *
+ * Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive
+ * values are treated as `1` so every successful pull emits a non-empty array.
+ *
  * **Example** (Batching iterator output)
  *
  * ```ts import.meta.vitest
@@ -804,15 +810,16 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Channel<A> => fromArray(Chu
 export const fromIteratorArray = <A, L>(
   iterator: LazyArg<Iterator<A, L>>,
   chunkSize = DefaultChunkSize
-): Channel<Arr.NonEmptyReadonlyArray<A>, never, L> =>
-  fromPull(
+): Channel<Arr.NonEmptyReadonlyArray<A>, never, L> => {
+  const size = Count.normalizeNonEmpty(chunkSize)
+  return fromPull(
     Effect.sync(() => {
       const iter = iterator()
       let done = Option.none<L>()
       return Effect.suspend(() => {
         if (done._tag === "Some") return Cause.done(done.value)
         const buffer: Array<A> = []
-        while (buffer.length < chunkSize) {
+        while (buffer.length < size) {
           const state = iter.next()
           if (state.done) {
             if (buffer.length === 0) {
@@ -827,6 +834,7 @@ export const fromIteratorArray = <A, L>(
       })
     })
   )
+}
 
 /**
  * Creates a `Channel` that emits all elements from an iterable.
@@ -850,6 +858,11 @@ export const fromIterable = <A, L>(iterable: Iterable<A, L>): Channel<A, never,
 /**
  * Creates a `Channel` that emits arrays of elements from an iterable.
  *
+ * **Details**
+ *
+ * Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive
+ * values are treated as `1`.
+ *
  * **Example** (Batching iterable output)
  *
  * ```ts import.meta.vitest
@@ -2180,7 +2193,7 @@ export const mapDoneEffect: {
 )
 
 const concurrencyIsSequential = (
-  concurrency: number | "unbounded" | undefined
+  concurrency: Types.Concurrency | undefined
 ) => concurrency === undefined || (concurrency !== "unbounded" && concurrency <= 1)
 
 /**
@@ -2251,7 +2264,7 @@ export const mapEffect: {
   <OutElem, OutElem1, OutErr1, Env1>(
     f: (d: OutElem, i: number) => Effect.Effect<OutElem1, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly unordered?: boolean | undefined
     }
   ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -2293,7 +2306,7 @@ export const mapEffect: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem, i: number) => Effect.Effect<OutElem1, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly unordered?: boolean | undefined
     }
   ): Channel<OutElem1, OutErr | OutErr1, OutDone, InElem, InErr, InDone, Env | Env1>
@@ -2303,7 +2316,7 @@ export const mapEffect: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem, i: number) => Effect.Effect<OutElem1, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly unordered?: boolean | undefined
     }
   ): Channel<OutElem1, OutErr | OutErr1, OutDone, InElem, InErr, InDone, Env | Env1> =>
@@ -2347,7 +2360,7 @@ const mapEffectConcurrent = <
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
   f: (o: OutElem, i: number) => Effect.Effect<OutElem2, EX, RX>,
   options: {
-    readonly concurrency: number | "unbounded"
+    readonly concurrency: Types.Concurrency
     readonly unordered?: boolean | undefined
   }
 ): Channel<OutElem2, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX> =>
@@ -2588,7 +2601,7 @@ export const tap: {
   <OutElem, X, OutErr1, Env1>(
     f: (d: Types.NoInfer<OutElem>) => Effect.Effect<X, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
     }
   ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
@@ -2632,7 +2645,7 @@ export const tap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: Types.NoInfer<OutElem>) => Effect.Effect<X, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
     }
   ): Channel<OutElem, OutErr | OutErr1, OutDone, InElem, InErr, InDone, Env | Env1>
 } = dual(
@@ -2641,7 +2654,7 @@ export const tap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: Types.NoInfer<OutElem>) => Effect.Effect<X, OutErr1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
     }
   ): Channel<OutElem, OutErr | OutErr1, OutDone, InElem, InErr, InDone, Env | Env1> =>
     mapEffect(self, (a) => Effect.as(f(a), a), options)
@@ -2723,7 +2736,7 @@ export const flatMap: {
   <OutElem, OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>(
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -2792,7 +2805,7 @@ export const flatMap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): Channel<
@@ -2825,7 +2838,7 @@ export const flatMap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): Channel<
@@ -2918,7 +2931,7 @@ const flatMapConcurrent = <
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
   f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
   options: {
-    readonly concurrency: number | "unbounded"
+    readonly concurrency: Types.Concurrency
     readonly bufferSize?: number | undefined
   }
 ): Channel<
@@ -5474,6 +5487,141 @@ export const catchCause: {
     })
   }))
 
+/**
+ * Recovers from defects using the provided function.
+ *
+ * **Details**
+ *
+ * Typed failures and interruptions are not caught.
+ *
+ * **Example** (Recovering from a defect)
+ *
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
+ *
+ * const channel = Channel.fromEffect(Effect.die("boom")).pipe(
+ *   Channel.catchDefect((defect) => Channel.succeed(`recovered: ${defect}`))
+ * )
+ *
+ * Effect.runSync(Channel.runCollect(channel)) // => ["recovered: boom"]
+ * ```
+ *
+ * @category error handling
+ * @since 4.0.0
+ */
+export const catchDefect: {
+  /**
+   * Recovers from defects using the provided function.
+   *
+   * **Details**
+   *
+   * Typed failures and interruptions are not caught.
+   *
+   * **Example** (Recovering from a defect)
+   *
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
+   *
+   * const channel = Channel.fromEffect(Effect.die("boom")).pipe(
+   *   Channel.catchDefect((defect) => Channel.succeed(`recovered: ${defect}`))
+   * )
+   *
+   * Effect.runSync(Channel.runCollect(channel)) // => ["recovered: boom"]
+   * ```
+   *
+   * @category error handling
+   * @since 4.0.0
+   */
+  <OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>(
+    f: (defect: unknown) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<
+    OutElem | OutElem1,
+    OutErr | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+  /**
+   * Recovers from defects using the provided function.
+   *
+   * **Details**
+   *
+   * Typed failures and interruptions are not caught.
+   *
+   * **Example** (Recovering from a defect)
+   *
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
+   *
+   * const channel = Channel.fromEffect(Effect.die("boom")).pipe(
+   *   Channel.catchDefect((defect) => Channel.succeed(`recovered: ${defect}`))
+   * )
+   *
+   * Effect.runSync(Channel.runCollect(channel)) // => ["recovered: boom"]
+   * ```
+   *
+   * @category error handling
+   * @since 4.0.0
+   */
+  <
+    OutElem,
+    OutErr,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1
+  >(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    f: (defect: unknown) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): Channel<
+    OutElem | OutElem1,
+    OutErr | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+} = dual(2, <
+  OutElem,
+  OutErr,
+  OutDone,
+  InElem,
+  InErr,
+  InDone,
+  Env,
+  OutElem1,
+  OutErr1,
+  OutDone1,
+  InElem1,
+  InErr1,
+  InDone1,
+  Env1
+>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  f: (defect: unknown) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+): Channel<
+  OutElem | OutElem1,
+  OutErr | OutErr1,
+  OutDone | OutDone1,
+  InElem & InElem1,
+  InErr & InErr1,
+  InDone & InDone1,
+  Env | Env1
+> => catchCauseFilter(self, Cause.findDefect, f))
+
 /**
  * Runs an effect with the full failure `Cause` when the channel fails, then
  * fails the returned channel with the original cause.
@@ -7810,7 +7958,7 @@ export const switchMap: {
   <OutElem, OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>(
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -7877,7 +8025,7 @@ export const switchMap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): Channel<
@@ -7910,7 +8058,7 @@ export const switchMap: {
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
     f: (d: OutElem) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): Channel<
@@ -8007,7 +8155,7 @@ export const mergeAll: {
    */
   (
     options: {
-      readonly concurrency: number | "unbounded"
+      readonly concurrency: Types.Concurrency
       readonly bufferSize?: number | undefined
       readonly switch?: boolean | undefined
     }
@@ -8077,7 +8225,7 @@ export const mergeAll: {
       Env
     >,
     options: {
-      readonly concurrency: number | "unbounded"
+      readonly concurrency: Types.Concurrency
       readonly bufferSize?: number | undefined
       readonly switch?: boolean | undefined
     }
@@ -8103,7 +8251,7 @@ export const mergeAll: {
       Env
     >,
     { bufferSize = 16, concurrency, switch: switch_ = false }: {
-      readonly concurrency: number | "unbounded"
+      readonly concurrency: Types.Concurrency
       readonly bufferSize?: number | undefined
       readonly switch?: boolean | undefined
     }
@@ -8646,9 +8794,8 @@ export const splitLines = <Err, Done>(): Channel<
       // Accumulates text that has not yet been terminated by a line break.
       // Content is carried across chunks until a terminator is found.
       let stringBuilder = ""
-      // Set when a chunk ends with \r so the next chunk can check whether
-      // the following character is \n (completing a \r\n pair) or not
-      // (standalone \r, which is itself a line terminator).
+      // A trailing \r completes the line immediately. Remember it only to
+      // suppress a leading \n in the next nonempty string.
       let midCRLF = false
       // Remembers the upstream Done value after the first time the upstream
       // signals completion, so subsequent pulls return Done immediately
@@ -8675,11 +8822,8 @@ export const splitLines = <Err, Done>(): Channel<
             let indexOfLF = str.indexOf("\n")
             if (midCRLF) {
               if (indexOfLF === 0) {
-                pushLine("")
                 from = 1
                 indexOfLF = str.indexOf("\n", from)
-              } else {
-                pushLine("")
               }
               midCRLF = false
             }
@@ -8689,18 +8833,19 @@ export const splitLines = <Err, Done>(): Channel<
                 from = indexOfLF + 1
                 indexOfLF = str.indexOf("\n", from)
               } else {
+                pushLine(str.substring(from, indexOfCR))
                 if (str.length === indexOfCR + 1) {
                   midCRLF = true
+                  from = str.length
                   indexOfCR = -1
                 } else {
-                  pushLine(str.substring(from, indexOfCR))
                   from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1)
                   indexOfCR = str.indexOf("\r", from)
                   indexOfLF = str.indexOf("\n", from)
                 }
               }
             }
-            stringBuilder = stringBuilder + str.substring(from, str.length - (midCRLF ? 1 : 0))
+            stringBuilder = stringBuilder + str.substring(from)
           }
         }
         return Arr.isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null
@@ -8715,7 +8860,7 @@ export const splitLines = <Err, Done>(): Channel<
           onFailure: Effect.failCause,
           onDone: (leftover) => {
             done = Option.some(leftover)
-            if (stringBuilder.length > 0 || midCRLF) {
+            if (stringBuilder.length > 0) {
               const last = stringBuilder
               stringBuilder = ""
               midCRLF = false
@@ -10623,7 +10768,7 @@ export const bind: {
     name: Exclude<N, keyof OutElem>,
     f: (a: NoInfer<OutElem>) => Channel<B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10671,7 +10816,7 @@ export const bind: {
     name: Exclude<N, keyof OutElem>,
     f: (a: NoInfer<OutElem>) => Channel<B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>,
     options?: {
-      readonly concurrency?: number | "unbounded" | undefined
+      readonly concurrency?: Types.Concurrency | undefined
       readonly bufferSize?: number | undefined
     }
   ): Channel<
@@ -10704,7 +10849,7 @@ export const bind: {
   name: Exclude<N, keyof OutElem>,
   f: (a: NoInfer<OutElem>) => Channel<B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>,
   options?: {
-    readonly concurrency?: number | "unbounded" | undefined
+    readonly concurrency?: Types.Concurrency | undefined
     readonly bufferSize?: number | undefined
   }
 ): Channel<
@@ -11026,6 +11171,11 @@ export const runForEachWhile: {
 /**
  * Concatenates a channel's `Uint8Array` chunks into a single `Uint8Array`.
  *
+ * **Gotchas**
+ *
+ * This materializes the full content in memory. The source channel must not
+ * reuse or mutate emitted buffers, which are retained until collection completes.
+ *
  * **Example** (Joining channel byte chunks)
  *
  * ```ts import.meta.vitest
@@ -11040,11 +11190,6 @@ export const runForEachWhile: {
  * Array.from(bytes) // => [1, 2, 3, 4]
  * ```
  *
- * **Gotchas**
- *
- * This materializes the full content in memory. The source channel must not
- * reuse or mutate emitted buffers, which are retained until collection completes.
- *
  * @category running
  * @since 4.0.0
  */
@@ -11113,16 +11258,6 @@ export const runCollect = <OutElem, OutErr, OutDone, Env>(
     return acc
   })
 
-/**
- * Runs a channel and outputs the done value.
- *
- * @category running
- * @since 4.0.0
- */
-export const runDone = <OutElem, OutErr, OutDone, Env>(
-  self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
-): Effect.Effect<OutDone, OutErr, Env> => runWith(self, identity_, Effect.succeed)
-
 /**
  * Runs a channel until the first output element is available, returning it in
  * an `Option`.