Class ScheduleDriverImpl

packages/effect/src/internal/schedule.ts:132–202

@internal

/** @internal */
class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In, R> {
  [ScheduleDriverTypeId] = scheduleDriverVariance

  constructor(
    readonly schedule: Schedule.Schedule<Out, In, R>,
    readonly ref: Ref.Ref<readonly [Option.Option<Out>, any]>
  ) {}

  get state(): Effect.Effect<unknown> {
    return core.map(ref.get(this.ref), (tuple) => tuple[1])
  }

  get last(): Effect.Effect<Out, Cause.NoSuchElementException> {
    return core.flatMap(ref.get(this.ref), ([element, _]) => {
      switch (element._tag) {
        case "None": {
          return core.failSync(() => new core.NoSuchElementException())
        }
        case "Some": {
          return core.succeed(element.value)
        }
      }
    })
  }

  iterationMeta = ref.unsafeMake(defaultIterationMetadata)

  get reset(): Effect.Effect<void> {
    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> {
    return pipe(
      core.map(ref.get(this.ref), (tuple) => tuple[1]),
      core.flatMap((state) =>
        pipe(
          Clock.currentTimeMillis,
          core.flatMap((now) =>
            pipe(
              core.suspend(() => this.schedule.step(now, input, state)),
              core.flatMap(([state, out, decision]) => {
                const setState = ref.set(this.ref, [Option.some(out), state] as const)
                if (ScheduleDecision.isDone(decision)) {
                  return setState.pipe(
                    core.zipRight(core.fail(Option.none()))
                  )
                }
                const millis = Intervals.start(decision.intervals) - now
                if (millis <= 0) {
                  return setState.pipe(
                    core.zipRight(updateInfo(this.iterationMeta, now, input, out)),
                    core.as(out)
                  )
                }
                const duration = Duration.millis(millis)
                return pipe(