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

package/src/RequestResolver.ts

@@ -17,7 +17,8 @@ import type * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { constTrue, dual, identity } from "./Function.ts"
-import { exitFail, exitSucceed } from "./internal/core.ts"
+import { exitSucceed } from "./internal/core.ts"
+import * as Count from "./internal/count.ts"
 import * as effect from "./internal/effect.ts"
 import * as internal from "./internal/request.ts"
 import * as Iterable from "./Iterable.ts"
@@ -528,17 +529,18 @@ export const fromEffectTagged = <A extends Request.Any & { readonly _tag: string
       return Effect.forEach(
         grouped,
         ([tag, requests]) =>
-          Effect.matchCause((fns[tag] as any)(requests) as Effect.Effect<Array<any>, unknown, unknown>, {
+          Effect.matchCause((fns[tag] as any)(requests) as Effect.Effect<Iterable<any>, unknown, unknown>, {
             onFailure: (cause) => {
               for (let i = 0; i < requests.length; i++) {
                 const entry = requests[i]
-                entry.completeUnsafe(exitFail(cause) as any)
+                entry.completeUnsafe(Exit.failCause(cause) as any)
               }
             },
             onSuccess: (res) => {
-              for (let i = 0; i < res.length; i++) {
-                const entry = requests[i]
-                entry.completeUnsafe(exitSucceed(res[i]) as any)
+              let i = 0
+              for (const result of res) {
+                const entry = requests[i++]
+                entry.completeUnsafe(exitSucceed(result) as any)
               }
             }
           }),
@@ -972,7 +974,8 @@ export const never: RequestResolver<never> = make(() => Effect.never)
  *
  * When more than `n` requests are waiting for the same resolver and batch key,
  * the current batch is run and additional requests are collected into later
- * batches.
+ * batches. Finite fractional values of `n` are rounded down. `NaN` and
+ * non-positive values are treated as `1` so that every batch remains non-empty.
  *
  * **Example** (Limiting parallel request batches)
  *
@@ -1025,7 +1028,8 @@ export const batchN: {
    *
    * When more than `n` requests are waiting for the same resolver and batch key,
    * the current batch is run and additional requests are collected into later
-   * batches.
+   * batches. Finite fractional values of `n` are rounded down. `NaN` and
+   * non-positive values are treated as `1` so that every batch remains non-empty.
    *
    * **Example** (Limiting parallel request batches)
    *
@@ -1078,7 +1082,8 @@ export const batchN: {
    *
    * When more than `n` requests are waiting for the same resolver and batch key,
    * the current batch is run and additional requests are collected into later
-   * batches.
+   * batches. Finite fractional values of `n` are rounded down. `NaN` and
+   * non-positive values are treated as `1` so that every batch remains non-empty.
    *
    * **Example** (Limiting parallel request batches)
    *
@@ -1123,11 +1128,13 @@ export const batchN: {
    * @since 2.0.0
    */
   <A extends Request.Any>(self: RequestResolver<A>, n: number): RequestResolver<A>
-} = dual(2, <A extends Request.Any>(self: RequestResolver<A>, n: number): RequestResolver<A> =>
-  makeWith({
+} = dual(2, <A extends Request.Any>(self: RequestResolver<A>, n: number): RequestResolver<A> => {
+  const size = Count.normalizeNonEmpty(n)
+  return makeWith({
     ...self,
-    collectWhile: (requests) => requests.size < n
-  }))
+    collectWhile: (requests) => requests.size < size
+  })
+})
 
 /**
  * Transforms a request resolver by grouping requests using the specified key
@@ -1808,8 +1815,9 @@ export const asCache: {
  *
  * **Gotchas**
  *
- * Entries do not expire by time, and completed failures are cached the same as
- * successes. Request equality controls cache hits.
+ * Entries do not expire by time, and completed failures without interruptions
+ * are cached the same as successes. Results containing interruptions are not
+ * cached. Request equality controls cache hits.
  *
  * @see {@link asCache} for exposing the resolver as a `Cache` with time-to-live and service lookup controls
  * @see {@link persisted} for backing persistable requests with the configured persistence store
@@ -1835,8 +1843,9 @@ export const withCache: {
    *
    * **Gotchas**
    *
-   * Entries do not expire by time, and completed failures are cached the same as
-   * successes. Request equality controls cache hits.
+   * Entries do not expire by time, and completed failures without interruptions
+   * are cached the same as successes. Results containing interruptions are not
+   * cached. Request equality controls cache hits.
    *
    * @see {@link asCache} for exposing the resolver as a `Cache` with time-to-live and service lookup controls
    * @see {@link persisted} for backing persistable requests with the configured persistence store
@@ -1867,8 +1876,9 @@ export const withCache: {
    *
    * **Gotchas**
    *
-   * Entries do not expire by time, and completed failures are cached the same as
-   * successes. Request equality controls cache hits.
+   * Entries do not expire by time, and completed failures without interruptions
+   * are cached the same as successes. Results containing interruptions are not
+   * cached. Request equality controls cache hits.
    *
    * @see {@link asCache} for exposing the resolver as a `Cache` with time-to-live and service lookup controls
    * @see {@link persisted} for backing persistable requests with the configured persistence store
@@ -1906,8 +1916,9 @@ export const withCache: {
      *
      * **Gotchas**
      *
-     * Entries do not expire by time, and completed failures are cached the same as
-     * successes. Request equality controls cache hits.
+     * Entries do not expire by time, and completed failures without interruptions
+     * are cached the same as successes. Results containing interruptions are not
+     * cached. Request equality controls cache hits.
      *
      * @see {@link asCache} for exposing the resolver as a `Cache` with time-to-live and service lookup controls
      * @see {@link persisted} for backing persistable requests with the configured persistence store
@@ -1932,8 +1943,9 @@ export const withCache: {
      *
      * **Gotchas**
      *
-     * Entries do not expire by time, and completed failures are cached the same as
-     * successes. Request equality controls cache hits.
+     * Entries do not expire by time, and completed failures without interruptions
+     * are cached the same as successes. Results containing interruptions are not
+     * cached. Request equality controls cache hits.
      *
      * @see {@link asCache} for exposing the resolver as a `Cache` with time-to-live and service lookup controls
      * @see {@link persisted} for backing persistable requests with the configured persistence store
@@ -1966,7 +1978,16 @@ export const withCache: {
           MutableHashMap.set(cache, entry.request, cached)
           const prevComplete = entry.completeUnsafe
           entry.completeUnsafe = function(exit) {
-            cached.exit = exit as any
+            if (Exit.hasInterrupts(exit)) {
+              if (cached.exit === undefined) {
+                const current = MutableHashMap.get(cache, entry.request)
+                if (current._tag === "Some" && current.value === cached) {
+                  MutableHashMap.remove(cache, entry.request)
+                }
+              }
+            } else {
+              cached.exit = exit as any
+            }
             prevComplete(exit)
           }
           return true
@@ -2133,6 +2154,7 @@ export const persisted: {
         >)
         const leftover: Array<Request.Entry<A>> = []
         const toPersist = new Map<A, Request.Result<A>>()
+        const completed = new Set<Request.Entry<A>>()
         for (let i = 0; i < results.length; i++) {
           const entry = entries[i]
           const exit = results[i]
@@ -2142,6 +2164,7 @@ export const persisted: {
           ) {
             const prevComplete = entry.completeUnsafe
             entry.completeUnsafe = function(exit) {
+              completed.add(entry)
               toPersist.set(entry.request, exit as any)
               prevComplete(exit)
             }
@@ -2153,10 +2176,10 @@ export const persisted: {
         if (!Arr.isArrayNonEmpty(leftover)) {
           return
         }
-        yield* Effect.catchCause(self.runAll(leftover, key), (cause) => {
+        yield* Effect.catchCause(Effect.suspend(() => self.runAll(leftover, key)), (cause) => {
           for (let i = 0; i < leftover.length; i++) {
             const entry = leftover[i]
-            if (!toPersist.has(entry.request)) continue
+            if (completed.has(entry)) continue
             entry.completeUnsafe(Exit.failCause(cause) as any)
           }
           return Effect.void

package/src/Result.ts

@@ -27,7 +27,7 @@ import type { Covariant, NoInfer, NotFunction } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
 import type * as Gen from "./Utils.ts"
 
-const TypeId = "~effect/data/Result"
+const TypeId = "~effect/Result"
 
 /**
  * A value that is either `Success<A, E>` or `Failure<A, E>`.

package/src/Scheduler.ts

@@ -80,25 +80,35 @@ export const Scheduler: Context.Reference<Scheduler> = Context.Reference<Schedul
   defaultValue: () => new MixedScheduler()
 })
 
-const setImmediate = "setImmediate" in globalThis
-  ? (f: () => void) => {
+const setMicrotask = (f: () => void) => {
+  let cancelled = false
+  Promise.resolve().then(() => {
+    if (!cancelled) f()
+  })
+  return (): void => {
+    cancelled = true
+  }
+}
+
+const setTimer: (f: () => void) => () => void = "setImmediate" in globalThis
+  ? (f) => {
     // @ts-ignore
     const timer = globalThis.setImmediate(f)
     // @ts-ignore
     return (): void => globalThis.clearImmediate(timer)
   }
-  : (f: () => void) => {
+  : (f) => {
     const timer = setTimeout(f, 0)
     return (): void => clearTimeout(timer)
   }
 
-const setMicrotask = (f: () => void) => {
-  let cancelled = false
-  Promise.resolve().then(() => {
-    if (!cancelled) f()
-  })
-  return (): void => {
-    cancelled = true
+// Some runtimes (e.g. Cloudflare Workers) throw when a timer is set in global
+// scope. Fall back to a microtask so effects can still yield at module load.
+const setImmediate = (f: () => void) => {
+  try {
+    return setTimer(f)
+  } catch {
+    return setMicrotask(f)
   }
 }
 
@@ -172,7 +182,7 @@ export class MixedScheduler implements Scheduler {
    * @since 2.0.0
    */
   shouldYield(fiber: Fiber.Fiber<unknown, unknown>) {
-    return fiber.currentOpCount >= fiber.maxOpsBeforeYield
+    return fiber.currentOpCount >= fiber.cache.maxOpsBeforeYield
   }
 
   /**