effect 3.15.4 → 3.16.0

package/src/internal/executionPlan.ts

@@ -0,0 +1,114 @@
+import type { Effect } from "../Effect.js"
+import * as Either from "../Either.js"
+import type * as Api from "../ExecutionPlan.js"
+import { dual } from "../Function.js"
+import * as Predicate from "../Predicate.js"
+import * as core from "./core.js"
+import * as layer from "./layer.js"
+import * as InternalSchedule from "./schedule.js"
+
+/** @internal */
+export const TypeId: Api.TypeId = Symbol.for("effect/ExecutionPlan") as Api.TypeId
+
+/** @internal */
+export const isExecutionPlan = (u: unknown): u is Api.ExecutionPlan<any> => Predicate.hasProperty(u, TypeId)
+
+/** @internal */
+export const withExecutionPlan: {
+  <Input, Provides, PlanE, PlanR>(
+    plan: Api.ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PlanE
+      requirements: PlanR
+    }>
+  ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
+    A,
+    E | PlanE,
+    Exclude<R, Provides> | PlanR
+  >
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+    effect: Effect<A, E, R>,
+    plan: Api.ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PlanE
+      requirements: PlanR
+    }>
+  ): Effect<
+    A,
+    E | PlanE,
+    Exclude<R, Provides> | PlanR
+  >
+} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+  effect: Effect<A, E, R>,
+  plan: Api.ExecutionPlan<{
+    provides: Provides
+    input: Input
+    error: PlanE
+    requirements: PlanR
+  }>
+) =>
+  core.suspend(() => {
+    let i = 0
+    let result: Either.Either<A, any> | undefined
+    return core.flatMap(
+      core.whileLoop({
+        while: () => i < plan.steps.length && (result === undefined || Either.isLeft(result)),
+        body: () => {
+          const step = plan.steps[i]
+          let nextEffect: Effect<A, any, any> = layer.effect_provide(effect, step.provide as any)
+          if (result) {
+            let attempted = false
+            const wrapped = nextEffect
+            // ensure the schedule is applied at least once
+            nextEffect = core.suspend(() => {
+              if (attempted) return wrapped
+              attempted = true
+              return result!
+            })
+            nextEffect = InternalSchedule.scheduleDefectRefail(
+              InternalSchedule.retry_Effect(nextEffect, scheduleFromStep(step, false)!)
+            )
+          } else {
+            const schedule = scheduleFromStep(step, true)
+            nextEffect = schedule
+              ? InternalSchedule.scheduleDefectRefail(InternalSchedule.retry_Effect(nextEffect, schedule))
+              : nextEffect
+          }
+          return core.either(nextEffect)
+        },
+        step: (either) => {
+          result = either
+          i++
+        }
+      }),
+      () => result!
+    )
+  }))
+
+/** @internal */
+export const scheduleFromStep = <Provides, In, PlanE, PlanR>(
+  step: Api.ExecutionPlan<{
+    provides: Provides
+    input: In
+    error: PlanE
+    requirements: PlanR
+  }>["steps"][number],
+  first: boolean
+) => {
+  if (!first) {
+    return InternalSchedule.fromRetryOptions({
+      schedule: step.schedule ? step.schedule : step.attempts ? undefined : InternalSchedule.once,
+      times: step.attempts,
+      while: step.while
+    })
+  } else if (step.attempts === 1 || !(step.schedule || step.attempts)) {
+    return undefined
+  }
+  return InternalSchedule.fromRetryOptions({
+    schedule: step.schedule,
+    while: step.while,
+    times: step.attempts ? step.attempts - 1 : undefined
+  })
+}

package/src/internal/hashMap.ts

@@ -287,6 +287,12 @@ export const hasHash = Dual.dual<
   <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1, hash: number) => boolean
 >(3, (self, key, hash) => Option.isSome(getHash(self, key, hash)))
 
+/** @internal */
+export const hasBy = Dual.dual<
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean) => (self: HM.HashMap<K, V>) => boolean,
+  <K, V>(self: HM.HashMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean) => boolean
+>(2, (self, predicate) => Option.isSome(findFirst(self, predicate)))
+
 /** @internal */
 export const set = Dual.dual<
   <K, V>(key: K, value: V) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,

package/src/internal/metric/polling.ts

@@ -7,9 +7,8 @@ import { pipeArguments } from "../../Pipeable.js"
 import type * as Schedule from "../../Schedule.js"
 import type * as Scope from "../../Scope.js"
 import * as core from "../core.js"
-import * as circular from "../effect/circular.js"
 import * as metric from "../metric.js"
-import * as schedule from "../schedule.js"
+import * as schedule_ from "../schedule.js"
 
 /** @internal */
 const MetricPollingSymbolKey = "effect/MetricPolling"
@@ -84,7 +83,7 @@ export const launch = dual<
   pipe(
     pollAndUpdate(self),
     core.zipRight(metric.value(self.metric)),
-    circular.scheduleForked(schedule)
+    schedule_.scheduleForked(schedule)
   ))
 
 /** @internal */
@@ -114,7 +113,7 @@ export const retry = dual<
     return pipeArguments(this, arguments)
   },
   metric: self.metric,
-  poll: schedule.retry_Effect(self.poll, policy)
+  poll: schedule_.retry_Effect(self.poll, policy)
 }))
 
 /** @internal */

package/src/internal/schedule.ts

@@ -8,6 +8,7 @@ import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
+import type * as Fiber from "../Fiber.js"
 import type { LazyArg } from "../Function.js"
 import { constVoid, dual, pipe } from "../Function.js"
 import * as Option from "../Option.js"
@@ -19,10 +20,12 @@ import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
+import type { Scope } from "../Scope.js"
 import type * as Types from "../Types.js"
 import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
+import { forkScoped } from "./effect/circular.js"
 import * as ref from "./ref.js"
 
 /** @internal */
@@ -45,6 +48,22 @@ export const ScheduleDriverTypeId: Schedule.ScheduleDriverTypeId = Symbol.for(
   ScheduleDriverSymbolKey
 ) as Schedule.ScheduleDriverTypeId
 
+/** @internal */
+const defaultIterationMetadata: Schedule.IterationMetadata = {
+  start: 0,
+  now: 0,
+  input: undefined,
+  elapsed: Duration.zero,
+  elapsedSincePrevious: Duration.zero,
+  recurrence: 0
+}
+
+/** @internal */
+export const CurrentIterationMetadata = Context.Reference<Schedule.CurrentIterationMetadata>()(
+  "effect/Schedule/CurrentIterationMetadata",
+  { defaultValue: () => defaultIterationMetadata }
+)
+
 const scheduleVariance = {
   /* c8 ignore next */
   _Out: (_: never) => _,
@@ -80,6 +99,31 @@ class ScheduleImpl<S, Out, In, R> implements Schedule.Schedule<Out, In, R> {
   }
 }
 
+/** @internal */
+const updateInfo = (
+  iterationMetaRef: Ref.Ref<Schedule.IterationMetadata>,
+  now: number,
+  input: unknown
+) =>
+  ref.update(iterationMetaRef, (prev) =>
+    (prev.recurrence === 0) ?
+      {
+        now,
+        input,
+        recurrence: prev.recurrence + 1,
+        elapsed: Duration.zero,
+        elapsedSincePrevious: Duration.zero,
+        start: now
+      } :
+      {
+        now,
+        input,
+        recurrence: prev.recurrence + 1,
+        elapsed: Duration.millis(now - prev.start),
+        elapsedSincePrevious: Duration.millis(now - prev.now),
+        start: prev.start
+      })
+
 /** @internal */
 class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In, R> {
   [ScheduleDriverTypeId] = scheduleDriverVariance
@@ -106,8 +150,12 @@ class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In,
     })
   }
 
+  iterationMeta = ref.unsafeMake(defaultIterationMetadata)
+
   get reset(): Effect.Effect<void> {
-    return ref.set(this.ref, [Option.none(), this.schedule.initial])
+    return ref.set(this.ref, [Option.none(), this.schedule.initial]).pipe(
+      core.zipLeft(ref.set(this.iterationMeta, defaultIterationMetadata))
+    )
   }
 
   next(input: In): Effect.Effect<Out, Option.Option<never>, R> {
@@ -122,15 +170,22 @@ class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In,
               core.flatMap(([state, out, decision]) => {
                 const setState = ref.set(this.ref, [Option.some(out), state] as const)
                 if (ScheduleDecision.isDone(decision)) {
-                  return core.zipRight(setState, core.fail(Option.none()))
+                  return setState.pipe(
+                    core.zipRight(core.fail(Option.none()))
+                  )
                 }
                 const millis = Intervals.start(decision.intervals) - now
                 if (millis <= 0) {
-                  return core.as(setState, out)
+                  return setState.pipe(
+                    core.zipRight(updateInfo(this.iterationMeta, now, input)),
+                    core.as(out)
+                  )
                 }
+                const duration = Duration.millis(millis)
                 return pipe(
                   setState,
-                  core.zipRight(effect.sleep(Duration.millis(millis))),
+                  core.zipRight(updateInfo(this.iterationMeta, now, input)),
+                  core.zipRight(effect.sleep(duration)),
                   core.as(out)
                 )
               })
@@ -1784,18 +1839,23 @@ class ScheduleDefect<E> {
 const isScheduleDefect = <E = unknown>(u: unknown): u is ScheduleDefect<E> => hasProperty(u, ScheduleDefectTypeId)
 const scheduleDefectWrap = <A, E, R>(self: Effect.Effect<A, E, R>) =>
   core.catchAll(self, (e) => core.die(new ScheduleDefect(e)))
-const scheduleDefectRefail = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  core.catchAllCause(self, (cause) =>
-    Option.match(
-      internalCause.find(
-        cause,
-        (_) => internalCause.isDieType(_) && isScheduleDefect<E>(_.defect) ? Option.some(_.defect) : Option.none()
-      ),
-      {
-        onNone: () => core.failCause(cause),
-        onSome: (error) => core.fail(error.error)
-      }
-    ))
+
+/** @internal */
+export const scheduleDefectRefailCause = <E>(cause: Cause.Cause<E>) =>
+  Option.match(
+    internalCause.find(
+      cause,
+      (_) => internalCause.isDieType(_) && isScheduleDefect<E>(_.defect) ? Option.some(_.defect) : Option.none()
+    ),
+    {
+      onNone: () => cause,
+      onSome: (error) => internalCause.fail(error.error)
+    }
+  )
+
+/** @internal */
+export const scheduleDefectRefail = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  core.catchAllCause(effect, (cause) => core.failCause(scheduleDefectRefailCause(cause)))
 
 /** @internal */
 export const repeat_Effect = dual<
@@ -1854,7 +1914,6 @@ export const repeat_combined = dual<{
     const withTimes = options.times ?
       intersect(withUntil, recurs(options.times)).pipe(map((intersectionPair) => intersectionPair[0])) :
       withUntil
-
     return scheduleDefectRefail(repeat_Effect(self, withTimes))
   }
 )
@@ -1874,7 +1933,22 @@ export const repeatOrElse_Effect = dual<
   core.flatMap(driver(schedule), (driver) =>
     core.matchEffect(self, {
       onFailure: (error) => orElse(error, Option.none()),
-      onSuccess: (value) => repeatOrElseEffectLoop(self, driver, orElse, value)
+      onSuccess: (value) =>
+        repeatOrElseEffectLoop(
+          effect.provideServiceEffect(
+            self,
+            CurrentIterationMetadata,
+            ref.get(driver.iterationMeta)
+          ),
+          driver,
+          (error, option) =>
+            effect.provideServiceEffect(
+              orElse(error, option),
+              CurrentIterationMetadata,
+              ref.get(driver.iterationMeta)
+            ),
+          value
+        )
     })))
 
 /** @internal */
@@ -1883,8 +1957,8 @@ const repeatOrElseEffectLoop = <A, E, R, R1, B, C, E2, R2>(
   driver: Schedule.ScheduleDriver<B, A, R1>,
   orElse: (error: E, option: Option.Option<B>) => Effect.Effect<C, E2, R2>,
   value: A
-): Effect.Effect<B | C, E2, R | R1 | R2> => {
-  return core.matchEffect(driver.next(value), {
+): Effect.Effect<B | C, E2, R | R1 | R2> =>
+  core.matchEffect(driver.next(value), {
     onFailure: () => core.orDie(driver.last),
     onSuccess: (b) =>
       core.matchEffect(self, {
@@ -1892,7 +1966,6 @@ const repeatOrElseEffectLoop = <A, E, R, R1, B, C, E2, R2>(
         onSuccess: (value) => repeatOrElseEffectLoop(self, driver, orElse, value)
       })
   })
-}
 
 /** @internal */
 export const retry_Effect = dual<
@@ -1921,41 +1994,47 @@ export const retry_combined: {
   ): Effect.Retry.Return<R, E, A, O>
   <A, E, R, B, R1>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<B, E, R1>
+    policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
   ): Effect.Effect<A, E, R1 | R>
 } = dual(
   2,
-  (self: Effect.Effect<any, any, any>, options: Effect.Retry.Options<any> | Schedule.Schedule<any, any, any>) => {
+  (
+    self: Effect.Effect<any, any, any>,
+    options: Effect.Retry.Options<any> | Schedule.Schedule<any, any, any>
+  ) => {
     if (isSchedule(options)) {
       return retry_Effect(self, options)
     }
-
-    const base = options.schedule ?? forever
-    const withWhile = options.while ?
-      whileInputEffect(base, (e) => {
-        const applied = options.while!(e)
-        if (typeof applied === "boolean") {
-          return core.succeed(applied)
-        }
-        return scheduleDefectWrap(applied)
-      }) :
-      base
-    const withUntil = options.until ?
-      untilInputEffect(withWhile, (e) => {
-        const applied = options.until!(e)
-        if (typeof applied === "boolean") {
-          return core.succeed(applied)
-        }
-        return scheduleDefectWrap(applied)
-      }) :
-      withWhile
-    const withTimes = options.times ?
-      intersect(withUntil, recurs(options.times)) :
-      withUntil
-    return scheduleDefectRefail(retry_Effect(self, withTimes))
+    return scheduleDefectRefail(retry_Effect(self, fromRetryOptions(options)))
   }
 )
 
+/** @internal */
+export const fromRetryOptions = (options: Effect.Retry.Options<any>): Schedule.Schedule<any, any, any> => {
+  const base = options.schedule ?? forever
+  const withWhile = options.while ?
+    whileInputEffect(base, (e) => {
+      const applied = options.while!(e)
+      if (typeof applied === "boolean") {
+        return core.succeed(applied)
+      }
+      return scheduleDefectWrap(applied)
+    }) :
+    base
+  const withUntil = options.until ?
+    untilInputEffect(withWhile, (e) => {
+      const applied = options.until!(e)
+      if (typeof applied === "boolean") {
+        return core.succeed(applied)
+      }
+      return scheduleDefectWrap(applied)
+    }) :
+    withWhile
+  return options.times ?
+    intersect(withUntil, recurs(options.times)) :
+    withUntil
+}
+
 /** @internal */
 export const retryOrElse_Effect = dual<
   <A1, E, R1, A2, E2, R2>(
@@ -1970,7 +2049,21 @@ export const retryOrElse_Effect = dual<
 >(3, (self, policy, orElse) =>
   core.flatMap(
     driver(policy),
-    (driver) => retryOrElse_EffectLoop(self, driver, orElse)
+    (driver) =>
+      retryOrElse_EffectLoop(
+        effect.provideServiceEffect(
+          self,
+          CurrentIterationMetadata,
+          ref.get(driver.iterationMeta)
+        ),
+        driver,
+        (e, out) =>
+          effect.provideServiceEffect(
+            orElse(e, out),
+            CurrentIterationMetadata,
+            ref.get(driver.iterationMeta)
+          )
+      )
   ))
 
 /** @internal */
@@ -2022,7 +2115,16 @@ export const scheduleFrom_Effect = dual<
 >(3, (self, initial, schedule) =>
   core.flatMap(
     driver(schedule),
-    (driver) => scheduleFrom_EffectLoop(self, initial, driver)
+    (driver) =>
+      scheduleFrom_EffectLoop(
+        effect.provideServiceEffect(
+          self,
+          CurrentIterationMetadata,
+          ref.get(driver.iterationMeta)
+        ),
+        initial,
+        driver
+      )
   ))
 
 /** @internal */
@@ -2033,7 +2135,11 @@ const scheduleFrom_EffectLoop = <In, E, R, R2, Out>(
 ): Effect.Effect<Out, E, R | R2> =>
   core.matchEffect(driver.next(initial), {
     onFailure: () => core.orDie(driver.last),
-    onSuccess: () => core.flatMap(self, (a) => scheduleFrom_EffectLoop(self, a, driver))
+    onSuccess: () =>
+      core.flatMap(
+        self,
+        (a) => scheduleFrom_EffectLoop(self, a, driver)
+      )
   })
 
 /** @internal */
@@ -2074,3 +2180,16 @@ export const once: Schedule.Schedule<void> = asVoid(recurs(1))
 
 /** @internal */
 export const stop: Schedule.Schedule<void> = asVoid(recurs(0))
+
+/** @internal */
+export const scheduleForked = dual<
+  <Out, R2>(
+    schedule: Schedule.Schedule<Out, unknown, R2>
+  ) => <A, E, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope>,
+  <A, E, R, Out, R2>(
+    self: Effect.Effect<A, E, R>,
+    schedule: Schedule.Schedule<Out, unknown, R2>
+  ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope>
+>(2, (self, schedule) => forkScoped(schedule_Effect(self, schedule)))