effect 4.0.0-beta.6 → 4.0.0-beta.7

package/src/Pool.ts

@@ -172,7 +172,7 @@ export const makeWithTTL = <A, E, R>(options: {
   readonly max: number
   readonly concurrency?: number | undefined
   readonly targetUtilization?: number | undefined
-  readonly timeToLive: Duration.DurationInput
+  readonly timeToLive: Duration.Input
   readonly timeToLiveStrategy?: "creation" | "usage" | undefined
 }): Effect.Effect<Pool<A, E>, never, R | Scope.Scope> =>
   Effect.flatMap(
@@ -473,10 +473,10 @@ const strategyNoop = <A, E>(): Strategy<A, E> => ({
   reclaim: (_) => Effect.undefined
 })
 
-const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const clock = yield* Clock
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
-  const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+  const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
   const creationTimes = new WeakMap<PoolItem<A, E>, number>()
   return identity<Strategy<A, E>>({
     run: (pool) => {
@@ -506,7 +506,7 @@ const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Dura
   })
 })
 
-const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
   return identity<Strategy<A, E>>({
     run: (pool) => {

package/src/Random.ts

@@ -23,8 +23,9 @@
  */
 import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
+import * as random from "./internal/random.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import type * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a service for generating random numbers.
@@ -49,23 +50,13 @@ import * as ServiceMap from "./ServiceMap.ts"
  * @since 4.0.0
  * @category Random Number Generators
  */
-export const Random = ServiceMap.Reference<{
+export const Random: ServiceMap.Reference<{
   nextIntUnsafe(): number
   nextDoubleUnsafe(): number
-}>("effect/Random", {
-  defaultValue: () => ({
-    nextIntUnsafe() {
-      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
-        Number.MIN_SAFE_INTEGER
-    },
-    nextDoubleUnsafe() {
-      return Math.random()
-    }
-  })
-})
+}> = random.Random
 
 const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effect<A> =>
-  Effect.withFiber((fiber) => Effect.succeed(f(ServiceMap.get(fiber.services, Random))))
+  Effect.withFiber((fiber) => Effect.succeed(f(fiber.getRef(Random))))
 
 /**
  * Generates a random number between 0 (inclusive) and 1 (inclusive).

package/src/RcMap.ts

@@ -292,7 +292,7 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity?: undefined
     }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
@@ -335,13 +335,13 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity: number
     }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityError>, never, Scope.Scope | R>
 } = <K, A, E, R>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+  readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
   readonly capacity?: number | undefined
 }) =>
   Effect.withFiber<RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
@@ -352,8 +352,8 @@ export const make: {
       services,
       scope,
       idleTimeToLive: typeof options.idleTimeToLive === "function"
-        ? flow(options.idleTimeToLive, Duration.fromDurationInputUnsafe)
-        : constant(Duration.fromDurationInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
+        ? flow(options.idleTimeToLive, Duration.fromInputUnsafe)
+        : constant(Duration.fromInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
       capacity: Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
     })
     return Effect.as(

package/src/RcRef.ts

@@ -120,7 +120,7 @@ export const make: <A, E, R>(
      * When the reference count reaches zero, the resource will be released
      * after this duration.
      */
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ) => Effect.Effect<RcRef<A, E>, never, R | Scope> = internal.make
 

package/src/RequestResolver.ts

@@ -652,7 +652,7 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  (duration: Duration.DurationInput): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
+  (duration: Duration.Input): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
   /**
    * Sets the batch delay window for this request resolver to the specified duration.
    *
@@ -683,10 +683,10 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A>
 } = dual(
   2,
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A> =>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A> =>
     makeWith({
       ...self,
       delay: Effect.sleep(duration)
@@ -1448,7 +1448,7 @@ export const asCache: {
   >(
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1475,7 +1475,7 @@ export const asCache: {
     self: RequestResolver<A>,
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): Effect.Effect<
@@ -1493,7 +1493,7 @@ export const asCache: {
   ServiceMode extends "lookup" | "construction" = never
 >(self: RequestResolver<A>, options: {
   readonly capacity: number
-  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   Cache.Cache<
@@ -1629,7 +1629,7 @@ export const persisted: {
   <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1647,7 +1647,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): Effect.Effect<
@@ -1663,7 +1663,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ) {

package/src/Schedule.ts

@@ -38,6 +38,7 @@ import type { LazyArg } from "./Function.ts"
 import { constant, dual, identity } from "./Function.ts"
 import { isEffect } from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
+import * as random from "./internal/random.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Pull from "./Pull.ts"
@@ -47,6 +48,8 @@ import type { Contravariant, Covariant, Mutable } from "./Types.ts"
 
 const TypeId = "~effect/Schedule"
 
+const randomNext: Effect<number> = random.Random.useSync((random) => random.nextDoubleUnsafe())
+
 /**
  * A Schedule defines a strategy for repeating or retrying effects based on some policy.
  *
@@ -747,7 +750,7 @@ export const addDelay: {
    * @since 2.0.0
    * @category utils
    */
-  <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(
+  <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.Input, Error2, Env2>): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
   /**
@@ -868,17 +871,16 @@ export const addDelay: {
    */
   <Output, Input, Error, Env, Error2 = never, Env2 = never>(
     self: Schedule<Output, Input, Error, Env>,
-    f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>
+    f: (output: Output) => Effect<Duration.Input, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
-  f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>
+  f: (output: Output) => Effect<Duration.Input, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   modifyDelay(
     self,
     (output, delay) =>
-      effect.map(f(output), (d) =>
-        Duration.sum(Duration.fromDurationInputUnsafe(d), Duration.fromDurationInputUnsafe(delay)))
+      effect.map(f(output), (d) => Duration.sum(Duration.fromInputUnsafe(d), Duration.fromInputUnsafe(delay)))
   ))
 
 /**
@@ -3020,8 +3022,8 @@ export const delays = <Out, In, E, R>(self: Schedule<Out, In, E, R>): Schedule<D
  * @since 2.0.0
  * @category constructors
  */
-export const duration = (durationInput: Duration.DurationInput): Schedule<Duration.Duration> => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+export const duration = (durationInput: Duration.Input): Schedule<Duration.Duration> => {
+  const duration = Duration.fromInputUnsafe(durationInput)
   return fromStepWithMetadata(effect.succeed((meta) =>
     meta.attempt === 1
       ? effect.succeed([duration, duration])
@@ -3114,10 +3116,10 @@ export const duration = (durationInput: Duration.DurationInput): Schedule<Durati
  * @since 4.0.0
  * @category constructors
  */
-export const during = (duration: Duration.DurationInput): Schedule<Duration.Duration> =>
+export const during = (duration: Duration.Input): Schedule<Duration.Duration> =>
   while_(
     elapsed,
-    ({ output }) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromDurationInputUnsafe(duration)))
+    ({ output }) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromInputUnsafe(duration)))
   )
 
 /**
@@ -3857,10 +3859,10 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  * @category constructors
  */
 export const exponential = (
-  base: Duration.DurationInput,
+  base: Duration.Input,
   factor: number = 2
 ): Schedule<Duration.Duration> => {
-  const baseMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(base))
+  const baseMillis = Duration.toMillis(Duration.fromInputUnsafe(base))
   return fromStepWithMetadata(effect.succeed((meta) => {
     const duration = Duration.millis(baseMillis * Math.pow(factor, meta.attempt - 1))
     return effect.succeed([duration, duration])
@@ -3931,8 +3933,8 @@ export const exponential = (
  * @since 2.0.0
  * @category constructors
  */
-export const fibonacci = (one: Duration.DurationInput): Schedule<Duration.Duration> => {
-  const oneMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(one))
+export const fibonacci = (one: Duration.Input): Schedule<Duration.Duration> => {
+  const oneMillis = Duration.toMillis(Duration.fromInputUnsafe(one))
   return fromStep(effect.sync(() => {
     let a = 0
     let b = oneMillis
@@ -4008,8 +4010,8 @@ export const fibonacci = (one: Duration.DurationInput): Schedule<Duration.Durati
  * @since 2.0.0
  * @category constructors
  */
-export const fixed = (interval: Duration.DurationInput): Schedule<number> => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval))
+export const fixed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.succeed([
       meta.attempt - 1,
@@ -4303,7 +4305,7 @@ export const modifyDelay: {
     f: (
       output: Output,
       delay: Duration.Duration
-    ) => Effect<Duration.DurationInput, Error2, Env2>
+    ) => Effect<Duration.Input, Error2, Env2>
   ): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
@@ -4343,22 +4345,39 @@ export const modifyDelay: {
     self: Schedule<Output, Input, Error, Env>,
     f: (
       output: Output,
-      delay: Duration.DurationInput
-    ) => Effect<Duration.DurationInput, Error2, Env2>
+      delay: Duration.Input
+    ) => Effect<Duration.Input, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   f: (
     output: Output,
-    delay: Duration.DurationInput
-  ) => Effect<Duration.DurationInput, Error2, Env2>
+    delay: Duration.Input
+  ) => Effect<Duration.Input, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => (now, input) =>
     effect.flatMap(
       step(now, input),
-      ([output, delay]) => effect.map(f(output, delay), (delay) => [output, Duration.fromDurationInputUnsafe(delay)])
+      ([output, delay]) => effect.map(f(output, delay), (delay) => [output, Duration.fromInputUnsafe(delay)])
     ))))
 
+/**
+ * Returns a new `Schedule` that randomly adjusts each recurrence delay.
+ *
+ * Delays are jittered between `80%` and `120%` of the original delay.
+ *
+ * @since 2.0.0
+ * @category utilities
+ */
+export const jittered = <Output, Input, Error, Env>(
+  self: Schedule<Output, Input, Error, Env>
+): Schedule<Output, Input, Error, Env> =>
+  modifyDelay(self, (_, delay) =>
+    effect.map(randomNext, (random) => {
+      const millis = Duration.toMillis(Duration.fromInputUnsafe(delay))
+      return Duration.millis(millis * 0.8 * (1 - random) + millis * 1.2 * random)
+    }))
+
 /**
  * Returns a new `Schedule` that outputs the inputs of the specified schedule.
  *
@@ -4867,8 +4886,8 @@ export const reduce: {
  * @since 2.0.0
  * @category constructors
  */
-export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
-  const decoded = Duration.fromDurationInputUnsafe(duration)
+export const spaced = (duration: Duration.Input): Schedule<number> => {
+  const decoded = Duration.fromInputUnsafe(duration)
   return fromStepWithMetadata(effect.succeed((meta) => effect.succeed([meta.attempt - 1, decoded])))
 }
 
@@ -5958,8 +5977,8 @@ export {
  * @since 2.0.0
  * @category constructors
  */
-export const windowed = (interval: Duration.DurationInput): Schedule<number> => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval))
+export const windowed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.sync(() => [
       meta.attempt - 1,

package/src/Schema.ts

@@ -325,7 +325,7 @@ export declare namespace Schema {
   /**
    * @since 4.0.0
    */
-  export type Type<S extends Top> = S["Type"]
+  export type Type<S> = S extends Top ? S["Type"] : never
 }
 
 /**
@@ -353,15 +353,15 @@ export declare namespace Codec {
   /**
    * @since 4.0.0
    */
-  export type Encoded<S extends Top> = S["Encoded"]
+  export type Encoded<S> = S extends Top ? S["Encoded"] : never
   /**
    * @since 4.0.0
    */
-  export type DecodingServices<S extends Top> = S["DecodingServices"]
+  export type DecodingServices<S> = S extends Top ? S["DecodingServices"] : never
   /**
    * @since 4.0.0
    */
-  export type EncodingServices<S extends Top> = S["EncodingServices"]
+  export type EncodingServices<S> = S extends Top ? S["EncodingServices"] : never
   /**
    * @since 4.0.0
    */

package/src/ScopedCache.ts

@@ -69,7 +69,7 @@ export const makeWith = <
 >(options: {
   readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
   readonly capacity: number
-  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   ScopedCache<Key, A, E, "lookup" extends ServiceMode ? Exclude<R, Scope.Scope> : never>,
@@ -88,7 +88,7 @@ export const makeWith = <
     self.state = { _tag: "Open", map }
     self.capacity = options.capacity
     self.timeToLive = options.timeToLive
-      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromDurationInputUnsafe(options.timeToLive!(exit, key))
+      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromInputUnsafe(options.timeToLive!(exit, key))
       : defaultTimeToLive
     return effect.as(
       Scope.addFinalizer(
@@ -116,7 +116,7 @@ export const make = <
   options: {
     readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
     readonly capacity: number
-    readonly timeToLive?: Duration.DurationInput | undefined
+    readonly timeToLive?: Duration.Input | undefined
     readonly requireServicesAt?: ServiceMode | undefined
   }
 ): Effect.Effect<