effect 2.3.1 → 2.3.3

package/src/FiberSet.ts

@@ -26,7 +26,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @categories models
  */
-export interface FiberSet<out A, out E = never>
+export interface FiberSet<out A = unknown, out E = unknown>
   extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>>
 {
   readonly [TypeId]: TypeId
@@ -92,7 +92,7 @@ const unsafeMake = <A, E>(): FiberSet<A, E> => {
  * @since 2.0.0
  * @categories constructors
  */
-export const make = <A, E = never>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
+export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
   Effect.acquireRelease(Effect.sync(() => unsafeMake<A, E>()), clear)
 
 /**
@@ -101,7 +101,7 @@ export const make = <A, E = never>(): Effect.Effect<FiberSet<A, E>, never, Scope
  * @since 2.0.0
  * @categories constructors
  */
-export const makeRuntime = <A, E = never, R = never>(): Effect.Effect<
+export const makeRuntime = <R = never, A = unknown, E = unknown>(): Effect.Effect<
   <XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
@@ -234,7 +234,7 @@ export const run: {
  * @since 2.0.0
  * @categories combinators
  */
-export const runtime: <A, E = never>(
+export const runtime: <A, E>(
   self: FiberSet<A, E>
 ) => <R = never>() => Effect.Effect<
   <XE extends E, XA extends A>(

package/src/Option.ts

@@ -648,12 +648,19 @@ export const flatMap: {
 export const andThen: {
   <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
   <B>(f: Option<B>): <A>(self: Option<A>) => Option<B>
+  <A, B>(f: (a: A) => B): (self: Option<A>) => Option<B>
+  <B>(f: B): <A>(self: Option<A>) => Option<B>
   <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
   <A, B>(self: Option<A>, f: Option<B>): Option<B>
+  <A, B>(self: Option<A>, f: (a: A) => B): Option<B>
+  <A, B>(self: Option<A>, f: B): Option<B>
 } = dual(
   2,
   <A, B>(self: Option<A>, f: (a: A) => Option<B> | Option<B>): Option<B> =>
-    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+    flatMap(self, (a) => {
+      const b = isFunction(f) ? f(a) : f
+      return isOption(b) ? b : some(b)
+    })
 )
 
 /**

package/src/RateLimiter.ts

@@ -1,9 +1,5 @@
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
- *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
  * @since 2.0.0
  */
@@ -13,11 +9,10 @@ import * as internal from "./internal/rateLimiter.js"
 import type { Scope } from "./Scope.js"
 
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Note that only the moment of starting the effect is rate limited: the number
+ * of concurrent executions is not bounded.
  *
  * @since 2.0.0
  * @category models
@@ -27,11 +22,113 @@ export interface RateLimiter {
 }
 
 /**
+ * @since 2.0.0
+ */
+export declare namespace RateLimiter {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Options {
+    /**
+     * The maximum number of requests that should be allowed.
+     */
+    readonly limit: number
+    /**
+     * The interval to utilize for rate-limiting requests. The semantics of the
+     * specified `interval` vary depending on the chosen `algorithm`:
+     *
+     * `token-bucket`: The maximum number of requests will be spread out over
+     * the provided interval if no tokens are available.
+     *
+     * For example, for a `RateLimiter` using the `token-bucket` algorithm with
+     * a `limit` of `10` and an `interval` of `1 seconds`, `1` request can be
+     * made every `100 millis`.
+     *
+     * `fixed-window`: The maximum number of requests will be reset during each
+     * interval. For example, for a `RateLimiter` using the `fixed-window`
+     * algorithm with a `limit` of `10` and an `interval` of `1 seconds`, a
+     * maximum of `10` requests can be made each second.
+     */
+    readonly interval: DurationInput
+    /**
+     * The algorithm to utilize for rate-limiting requests.
+     *
+     * Defaults to `token-bucket`.
+     */
+    readonly algorithm?: "fixed-window" | "token-bucket"
+  }
+}
+
+/**
+ * Constructs a new `RateLimiter` which will utilize the specified algorithm
+ * to limit requests (defaults to `token-bucket`).
+ *
+ * Notes
+ * - Only the moment of starting the effect is rate limited. The number of concurrent executions is not bounded.
+ * - Instances of `RateLimiter` can be composed.
+ * - The "cost" per effect can be changed. See {@link withCost}
+ *
+ * @example
+ * import { Effect, RateLimiter } from "effect";
+ * import { compose } from "effect/Function"
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* ($) {
+ *     const perMinuteRL = yield* $(RateLimiter.make({ limit: 30, interval: "1 minutes" }))
+ *     const perSecondRL = yield* $(RateLimiter.make({ limit: 2, interval: "1 seconds" }))
+ *
+ *     // This rate limiter respects both the 30 calls per minute
+ *     // and the 2 calls per second constraints.
+ *      const rateLimit = compose(perMinuteRL, perSecondRL)
+ *
+ *     // simulate repeated calls
+ *     for (let n = 0; n < 100; n++) {
+ *       // wrap the effect we want to limit with rateLimit
+ *       yield* $(rateLimit(Effect.log("Calling RateLimited Effect")));
+ *     }
+ *   })
+ * );
+ *
  * @since 2.0.0
  * @category constructors
  */
-export const make: (limit: number, window: DurationInput) => Effect<
-  RateLimiter,
-  never,
-  Scope
-> = internal.make
+export const make: (options: RateLimiter.Options) => Effect<RateLimiter, never, Scope> = internal.make
+
+/**
+ * Alters the per-effect cost of the rate-limiter.
+ *
+ * This can be used for "credit" based rate-limiting where different API endpoints
+ * cost a different number of credits within a time window.
+ * Eg: 1000 credits / hour, where a query costs 1 credit and a mutation costs 5 credits.
+ *
+ * @example
+ * import { Effect, RateLimiter } from "effect";
+ * import { compose } from "effect/Function";
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* ($) {
+ *     // Create a rate limiter that has an hourly limit of 1000 credits
+ *     const rateLimiter = yield* $(RateLimiter.make({ limit: 1000, interval: "1 hours" }));
+ *     // Query API costs 1 credit per call ( 1 is the default cost )
+ *     const queryAPIRL = compose(rateLimiter, RateLimiter.withCost(1));
+ *     // Mutation API costs 5 credits per call
+ *     const mutationAPIRL = compose(rateLimiter, RateLimiter.withCost(5));
+
+ *     // Use the pre-defined rate limiters
+ *     yield* $(queryAPIRL(Effect.log("Sample Query")));
+ *     yield* $(mutationAPIRL(Effect.log("Sample Mutation")));
+ *
+ *     // Or set a cost on-the-fly
+ *     yield* $(
+ *       rateLimiter(Effect.log("Another query with a different cost")).pipe(
+ *         RateLimiter.withCost(3)
+ *       )
+ *     );
+ *   })
+ * );
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const withCost: (cost: number) => <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R> = internal.withCost

package/src/Scheduler.ts

@@ -8,7 +8,6 @@ import type { FiberRef } from "./FiberRef.js"
 import { dual } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
 import * as core from "./internal/core.js"
-import * as timeout from "./internal/timeout.js"
 
 /**
  * @since 2.0.0
@@ -107,7 +106,7 @@ export class MixedScheduler implements Scheduler {
    */
   private starve(depth = 0) {
     if (depth >= this.maxNextTickBeforeTimer) {
-      timeout.set(() => this.starveInternal(0), 0)
+      setTimeout(() => this.starveInternal(0), 0)
     } else {
       Promise.resolve(void 0).then(() => this.starveInternal(depth + 1))
     }
@@ -337,14 +336,14 @@ export const makeBatched = (
  * @category constructors
  */
 export const timer = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
-  make((task) => timeout.set(task, ms), shouldYield)
+  make((task) => setTimeout(task, ms), shouldYield)
 
 /**
  * @since 2.0.0
  * @category constructors
  */
 export const timerBatched = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
-  makeBatched((task) => timeout.set(task, ms), shouldYield)
+  makeBatched((task) => setTimeout(task, ms), shouldYield)
 
 /** @internal */
 export const currentScheduler: FiberRef<Scheduler> = globalValue(

package/src/index.ts

@@ -545,11 +545,7 @@ export * as Queue from "./Queue.js"
 export * as Random from "./Random.js"
 
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
- *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
  * @since 2.0.0
  */

package/src/internal/clock.ts

@@ -5,7 +5,6 @@ import type * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
 import { constFalse } from "../Function.js"
 import * as core from "./core.js"
-import * as timeout from "./timeout.js"
 
 /** @internal */
 const ClockSymbolKey = "effect/Clock"
@@ -29,12 +28,12 @@ export const globalClockScheduler: Clock.ClockScheduler = {
       return constFalse
     }
     let completed = false
-    const handle = timeout.set(() => {
+    const handle = setTimeout(() => {
       completed = true
       task()
     }, millis)
     return () => {
-      timeout.clear(handle)
+      clearTimeout(handle)
       return !completed
     }
   }

package/src/internal/effect/circular.ts

@@ -65,22 +65,24 @@ class Semaphore {
       return Either.right(core.succeed(n))
     })
 
-  readonly updateTaken = (f: (n: number) => number): Effect.Effect<void> =>
+  readonly updateTaken = (f: (n: number) => number): Effect.Effect<number> =>
     core.withFiberRuntime((fiber) => {
       this.taken = f(this.taken)
-      fiber.getFiberRef(currentScheduler).scheduleTask(() => {
-        const iter = this.waiters.values()
-        let item = iter.next()
-        while (item.done === false && item.value() === true) {
-          item = iter.next()
-        }
-      }, fiber.getFiberRef(core.currentSchedulingPriority))
-      return core.unit
+      if (this.waiters.size > 0) {
+        fiber.getFiberRef(currentScheduler).scheduleTask(() => {
+          const iter = this.waiters.values()
+          let item = iter.next()
+          while (item.done === false && item.value() === true) {
+            item = iter.next()
+          }
+        }, fiber.getFiberRef(core.currentSchedulingPriority))
+      }
+      return core.succeed(this.free)
     })
 
-  readonly release = (n: number): Effect.Effect<void> => this.updateTaken((taken) => taken - n)
+  readonly release = (n: number): Effect.Effect<number> => this.updateTaken((taken) => taken - n)
 
-  readonly releaseAll: Effect.Effect<void> = this.updateTaken((_) => 0)
+  readonly releaseAll: Effect.Effect<number> = this.updateTaken((_) => 0)
 
   readonly withPermits = (n: number) => <R, E, A>(self: Effect.Effect<R, E, A>) =>
     core.uninterruptibleMask((restore) =>

package/src/internal/fiberRuntime.ts

@@ -2771,7 +2771,12 @@ export const zipLeftOptions = dual<
   ) => Effect.Effect<A, E | E2, R | R2>
 >(
   (args) => core.isEffect(args[1]),
-  (self, that, options) => zipWithOptions(self, that, (a, _) => a, options)
+  (self, that, options) => {
+    if (options?.concurrent !== true && (options?.batching === undefined || options.batching === false)) {
+      return core.zipLeft(self, that)
+    }
+    return zipWithOptions(self, that, (a, _) => a, options)
+  }
 )
 
 /** @internal */
@@ -2794,11 +2799,16 @@ export const zipRightOptions: {
 } = dual((args) => core.isEffect(args[1]), <A, E, R, A2, E2, R2>(
   self: Effect.Effect<A, E, R>,
   that: Effect.Effect<A2, E2, R2>,
-  options: {
+  options?: {
     readonly concurrent?: boolean | undefined
     readonly batching?: boolean | "inherit" | undefined
   }
-): Effect.Effect<A2, E2 | E, R2 | R> => zipWithOptions(self, that, (_, b) => b, options))
+): Effect.Effect<A2, E2 | E, R2 | R> => {
+  if (options?.concurrent !== true && (options?.batching === undefined || options.batching === false)) {
+    return core.zipRight(self, that)
+  }
+  return zipWithOptions(self, that, (_, b) => b, options)
+})
 
 /** @internal */
 export const zipWithOptions: {

package/src/internal/rateLimiter.ts

@@ -1,30 +1,92 @@
 import type { DurationInput } from "../Duration.js"
+import * as Duration from "../Duration.js"
 import * as Effect from "../Effect.js"
-import type { RateLimiter } from "../RateLimiter.js"
-import type { Scope } from "../Scope.js"
-import * as SynchronizedRef from "../SynchronizedRef.js"
+import * as FiberRef from "../FiberRef.js"
+import { globalValue } from "../GlobalValue.js"
+import type * as RateLimiter from "../RateLimiter.js"
+import type * as Scope from "../Scope.js"
 
 /** @internal */
-export const make = (limit: number, window: DurationInput): Effect.Effect<
-  RateLimiter,
+export const make = ({
+  algorithm = "token-bucket",
+  interval,
+  limit
+}: RateLimiter.RateLimiter.Options): Effect.Effect<
+  RateLimiter.RateLimiter,
   never,
-  Scope
+  Scope.Scope
+> => {
+  switch (algorithm) {
+    case "fixed-window": {
+      return fixedWindow(limit, interval)
+    }
+    case "token-bucket": {
+      return tokenBucket(limit, interval)
+    }
+  }
+}
+
+const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
+  RateLimiter.RateLimiter,
+  never,
+  Scope.Scope
 > =>
   Effect.gen(function*(_) {
-    const scope = yield* _(Effect.scope)
+    const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
     const semaphore = yield* _(Effect.makeSemaphore(limit))
-    const ref = yield* _(SynchronizedRef.make(false))
-    const reset = SynchronizedRef.updateEffect(
-      ref,
-      (running) =>
-        running ? Effect.succeed(true) : Effect.sleep(window).pipe(
-          Effect.zipRight(SynchronizedRef.set(ref, false)),
-          Effect.zipRight(semaphore.releaseAll),
-          Effect.forkIn(scope),
-          Effect.interruptible,
-          Effect.as(true)
-        )
+    const latch = yield* _(Effect.makeSemaphore(0))
+    const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
+      Effect.zipRight(latch.releaseAll),
+      Effect.zipRight(semaphore.release(1)),
+      Effect.flatMap((free) => free === limit ? Effect.unit : refill)
+    )
+    yield* _(
+      latch.take(1),
+      Effect.zipRight(refill),
+      Effect.forever,
+      Effect.forkScoped,
+      Effect.interruptible
+    )
+    const take = Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(
+        FiberRef.get(currentCost),
+        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
+      )
     )
-    const take = Effect.zipRight(semaphore.take(1), reset)
     return (effect) => Effect.zipRight(take, effect)
   })
+
+const fixedWindow = (limit: number, window: DurationInput): Effect.Effect<
+  RateLimiter.RateLimiter,
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function*(_) {
+    const semaphore = yield* _(Effect.makeSemaphore(limit))
+    const latch = yield* _(Effect.makeSemaphore(0))
+    yield* _(
+      latch.take(1),
+      Effect.zipRight(Effect.sleep(window)),
+      Effect.zipRight(latch.releaseAll),
+      Effect.zipRight(semaphore.releaseAll),
+      Effect.forever,
+      Effect.forkScoped,
+      Effect.interruptible
+    )
+    const take = Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(
+        FiberRef.get(currentCost),
+        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
+      )
+    )
+    return (effect) => Effect.zipRight(take, effect)
+  })
+
+/** @internal */
+const currentCost = globalValue(
+  Symbol.for("effect/RateLimiter/currentCost"),
+  () => FiberRef.unsafeMake(1)
+)
+
+/** @internal */
+export const withCost = (cost: number) => Effect.locally(currentCost, cost)

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.3.1"
+export const moduleVersion = "2.3.3"

package/dist/cjs/internal/timeout.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.set = exports.clear = void 0;
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-/** @internal */
-const isBun = typeof process === "undefined" ? false : !!process?.isBun;
-/** @internal */
-const clear = exports.clear = isBun ? id => clearInterval(id) : id => clearTimeout(id);
-/** @internal */
-const set = exports.set = isBun ? (fn, ms) => {
-  const id = setInterval(() => {
-    fn();
-    clearInterval(id);
-  }, ms);
-  return id;
-} : (fn, ms) => setTimeout(fn, ms);
-//# sourceMappingURL=timeout.js.map

package/dist/cjs/internal/timeout.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.js","names":["isBun","process","clear","exports","id","clearInterval","clearTimeout","set","fn","ms","setInterval","setTimeout"],"sources":["../../../src/internal/timeout.ts"],"sourcesContent":[null],"mappings":";;;;;;AAAA;;;;;AAMA;AACA,MAAMA,KAAK,GAAG,OAAOC,OAAO,KAAK,WAAW,GAAG,KAAK,GAAG,CAAC,CAAGA,OAAe,EAAED,KAAM;AAElF;AACO,MAAME,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAAiCF,KAAK,GAAII,EAAE,IAAKC,aAAa,CAACD,EAAE,CAAC,GAAIA,EAAE,IAAKE,YAAY,CAACF,EAAE,CAAC;AAE/G;AACO,MAAMG,GAAG,GAAAJ,OAAA,CAAAI,GAAA,GAAmDP,KAAK,GACtE,CAACQ,EAAc,EAAEC,EAAU,KAAI;EAC7B,MAAML,EAAE,GAAGM,WAAW,CAAC,MAAK;IAC1BF,EAAE,EAAE;IACJH,aAAa,CAACD,EAAE,CAAC;EACnB,CAAC,EAAEK,EAAE,CAAC;EAEN,OAAOL,EAAE;AACX,CAAC,GACD,CAACI,EAAc,EAAEC,EAAU,KAAKE,UAAU,CAACH,EAAE,EAAEC,EAAE,CAAC"}

package/dist/dts/internal/timeout.d.ts

@@ -1,7 +0,0 @@
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-export {};
-//# sourceMappingURL=timeout.d.ts.map

package/dist/dts/internal/timeout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../src/internal/timeout.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/esm/internal/timeout.js

@@ -1,18 +0,0 @@
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-/** @internal */
-const isBun = typeof process === "undefined" ? false : !!process?.isBun;
-/** @internal */
-export const clear = isBun ? id => clearInterval(id) : id => clearTimeout(id);
-/** @internal */
-export const set = isBun ? (fn, ms) => {
-  const id = setInterval(() => {
-    fn();
-    clearInterval(id);
-  }, ms);
-  return id;
-} : (fn, ms) => setTimeout(fn, ms);
-//# sourceMappingURL=timeout.js.map

package/dist/esm/internal/timeout.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.js","names":["isBun","process","clear","id","clearInterval","clearTimeout","set","fn","ms","setInterval","setTimeout"],"sources":["../../../src/internal/timeout.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAMA;AACA,MAAMA,KAAK,GAAG,OAAOC,OAAO,KAAK,WAAW,GAAG,KAAK,GAAG,CAAC,CAAGA,OAAe,EAAED,KAAM;AAElF;AACA,OAAO,MAAME,KAAK,GAAiCF,KAAK,GAAIG,EAAE,IAAKC,aAAa,CAACD,EAAE,CAAC,GAAIA,EAAE,IAAKE,YAAY,CAACF,EAAE,CAAC;AAE/G;AACA,OAAO,MAAMG,GAAG,GAAmDN,KAAK,GACtE,CAACO,EAAc,EAAEC,EAAU,KAAI;EAC7B,MAAML,EAAE,GAAGM,WAAW,CAAC,MAAK;IAC1BF,EAAE,EAAE;IACJH,aAAa,CAACD,EAAE,CAAC;EACnB,CAAC,EAAEK,EAAE,CAAC;EAEN,OAAOL,EAAE;AACX,CAAC,GACD,CAACI,EAAc,EAAEC,EAAU,KAAKE,UAAU,CAACH,EAAE,EAAEC,EAAE,CAAC"}

package/src/internal/timeout.ts

@@ -1,23 +0,0 @@
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-
-/** @internal */
-const isBun = typeof process === "undefined" ? false : !!((process as any)?.isBun)
-
-/** @internal */
-export const clear: (id: NodeJS.Timeout) => void = isBun ? (id) => clearInterval(id) : (id) => clearTimeout(id)
-
-/** @internal */
-export const set: (fn: () => void, ms: number) => NodeJS.Timeout = isBun ?
-  (fn: () => void, ms: number) => {
-    const id = setInterval(() => {
-      fn()
-      clearInterval(id)
-    }, ms)
-
-    return id
-  } :
-  (fn: () => void, ms: number) => setTimeout(fn, ms)