effect 2.0.0-next.9 → 2.0.0

package/dist/esm/internal/schedule.js

@@ -0,0 +1,715 @@
+import * as Chunk from "../Chunk.js";
+import * as Clock from "../Clock.js";
+import * as Context from "../Context.js";
+import * as Duration from "../Duration.js";
+import * as Either from "../Either.js";
+import * as Equal from "../Equal.js";
+import { constVoid, dual, pipe } from "../Function.js";
+import * as Option from "../Option.js";
+import { pipeArguments } from "../Pipeable.js";
+import * as Random from "../Random.js";
+import * as ScheduleDecision from "../ScheduleDecision.js";
+import * as Interval from "../ScheduleInterval.js";
+import * as Intervals from "../ScheduleIntervals.js";
+import * as effect from "./core-effect.js";
+import * as core from "./core.js";
+import * as ref from "./ref.js";
+/** @internal */
+const ScheduleSymbolKey = "effect/Schedule";
+/** @internal */
+export const ScheduleTypeId = /*#__PURE__*/Symbol.for(ScheduleSymbolKey);
+/** @internal */
+const ScheduleDriverSymbolKey = "effect/ScheduleDriver";
+/** @internal */
+export const ScheduleDriverTypeId = /*#__PURE__*/Symbol.for(ScheduleDriverSymbolKey);
+const scheduleVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _In: _ => _,
+  /* c8 ignore next */
+  _Out: _ => _
+};
+const scheduleDriverVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _In: _ => _,
+  /* c8 ignore next */
+  _Out: _ => _
+};
+/** @internal */
+class ScheduleImpl {
+  initial;
+  step;
+  [ScheduleTypeId] = scheduleVariance;
+  constructor(initial, step) {
+    this.initial = initial;
+    this.step = step;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+/** @internal */
+class ScheduleDriverImpl {
+  schedule;
+  ref;
+  [ScheduleDriverTypeId] = scheduleDriverVariance;
+  constructor(schedule, ref) {
+    this.schedule = schedule;
+    this.ref = ref;
+  }
+  get state() {
+    return core.map(ref.get(this.ref), tuple => tuple[1]);
+  }
+  get last() {
+    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);
+          }
+      }
+    });
+  }
+  get reset() {
+    return ref.set(this.ref, [Option.none(), this.schedule.initial]);
+  }
+  next(input) {
+    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]) => ScheduleDecision.isDone(decision) ? pipe(ref.set(this.ref, [Option.some(out), state]), core.zipRight(core.fail(Option.none()))) : pipe(ref.set(this.ref, [Option.some(out), state]), core.zipRight(effect.sleep(Duration.millis(Intervals.start(decision.intervals) - now))), core.as(out))))))));
+  }
+}
+/** @internal */
+export const makeWithState = (initial, step) => new ScheduleImpl(initial, step);
+/** @internal */
+export const addDelay = /*#__PURE__*/dual(2, (self, f) => addDelayEffect(self, out => core.sync(() => f(out))));
+/** @internal */
+export const addDelayEffect = /*#__PURE__*/dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map(f(out), delay => Duration.sum(duration, Duration.decode(delay)))));
+/** @internal */
+export const andThen = /*#__PURE__*/dual(2, (self, that) => map(andThenEither(self, that), Either.merge));
+/** @internal */
+export const andThenEither = /*#__PURE__*/dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap(self.step(now, input, state[0]), ([lState, out, decision]) => {
+  if (ScheduleDecision.isDone(decision)) {
+    return core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either.right(out), decision]);
+  }
+  return core.succeed([[lState, state[1], true], Either.left(out), decision]);
+}) : core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either.right(out), decision])));
+/** @internal */
+export const as = /*#__PURE__*/dual(2, (self, out) => map(self, () => out));
+/** @internal */
+export const asUnit = self => map(self, constVoid);
+/** @internal */
+export const bothInOut = /*#__PURE__*/dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, [in1, in2], state) => core.zipWith(self.step(now, in1, state[0]), that.step(now, in2, state[1]), ([lState, out, lDecision], [rState, out2, rDecision]) => {
+  if (ScheduleDecision.isContinue(lDecision) && ScheduleDecision.isContinue(rDecision)) {
+    const interval = pipe(lDecision.intervals, Intervals.union(rDecision.intervals));
+    return [[lState, rState], [out, out2], ScheduleDecision.continue(interval)];
+  }
+  return [[lState, rState], [out, out2], ScheduleDecision.done];
+})));
+/** @internal */
+export const check = /*#__PURE__*/dual(2, (self, test) => checkEffect(self, (input, out) => core.sync(() => test(input, out))));
+/** @internal */
+export const checkEffect = /*#__PURE__*/dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+  if (ScheduleDecision.isDone(decision)) {
+    return core.succeed([state, out, ScheduleDecision.done]);
+  }
+  return core.map(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision.done]);
+})));
+/** @internal */
+export const collectAllInputs = () => collectAllOutputs(identity());
+/** @internal */
+export const collectAllOutputs = self => reduce(self, Chunk.empty(), (outs, out) => pipe(outs, Chunk.append(out)));
+/** @internal */
+export const collectUntil = f => collectAllOutputs(recurUntil(f));
+/** @internal */
+export const collectUntilEffect = f => collectAllOutputs(recurUntilEffect(f));
+/** @internal */
+export const collectWhile = f => collectAllOutputs(recurWhile(f));
+/** @internal */
+export const collectWhileEffect = f => collectAllOutputs(recurWhileEffect(f));
+/** @internal */
+export const compose = /*#__PURE__*/dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision.done] : ScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision.continue(pipe(lDecision.intervals, Intervals.max(rDecision.intervals)))]))));
+/** @internal */
+export const mapInput = /*#__PURE__*/dual(2, (self, f) => mapInputEffect(self, input2 => core.sync(() => f(input2))));
+/** @internal */
+export const mapInputContext = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.mapInputContext(self.step(now, input, state), f)));
+/** @internal */
+export const mapInputEffect = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap(f(input2), input => self.step(now, input, state))));
+/** @internal */
+export const dayOfMonth = day => {
+  return makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
+    if (!Number.isInteger(day) || day < 1 || 31 < day) {
+      return core.dieSync(() => new core.IllegalArgumentException(`Invalid argument in: dayOfMonth(${day}). Must be in range 1...31`));
+    }
+    const n = state[1];
+    const initial = n === 0;
+    const day0 = nextDayOfMonth(now, day, initial);
+    const start = beginningOfDay(day0);
+    const end = endOfDay(day0);
+    const interval = Interval.make(start, end);
+    return core.succeed([[end, n + 1], n, ScheduleDecision.continueWith(interval)]);
+  });
+};
+/** @internal */
+export const dayOfWeek = day => {
+  return makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
+    if (!Number.isInteger(day) || day < 1 || 7 < day) {
+      return core.dieSync(() => new core.IllegalArgumentException(`Invalid argument in: dayOfWeek(${day}). Must be in range 1 (Monday)...7 (Sunday)`));
+    }
+    const n = state[1];
+    const initial = n === 0;
+    const day0 = nextDay(now, day, initial);
+    const start = beginningOfDay(day0);
+    const end = endOfDay(day0);
+    const interval = Interval.make(start, end);
+    return core.succeed([[end, n + 1], n, ScheduleDecision.continueWith(interval)]);
+  });
+};
+/** @internal */
+export const delayed = /*#__PURE__*/dual(2, (self, f) => delayedEffect(self, duration => core.sync(() => f(duration))));
+/** @internal */
+export const delayedEffect = /*#__PURE__*/dual(2, (self, f) => modifyDelayEffect(self, (_, delay) => f(delay)));
+/** @internal */
+export const delayedSchedule = schedule => addDelay(schedule, x => x);
+/** @internal */
+export const delays = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), core.flatMap(([state, _, decision]) => {
+  if (ScheduleDecision.isDone(decision)) {
+    return core.succeed([state, Duration.zero, decision]);
+  }
+  return core.succeed([state, Duration.millis(Intervals.start(decision.intervals) - now), decision]);
+})));
+/** @internal */
+export const mapBoth = /*#__PURE__*/dual(2, (self, {
+  onInput,
+  onOutput
+}) => map(mapInput(self, onInput), onOutput));
+/** @internal */
+export const mapBothEffect = /*#__PURE__*/dual(2, (self, {
+  onInput,
+  onOutput
+}) => mapEffect(mapInputEffect(self, onInput), onOutput));
+/** @internal */
+export const driver = self => pipe(ref.make([Option.none(), self.initial]), core.map(ref => new ScheduleDriverImpl(self, ref)));
+/** @internal */
+export const duration = durationInput => {
+  const duration = Duration.decode(durationInput);
+  const durationMillis = Duration.toMillis(duration);
+  return makeWithState(true, (now, _, state) => core.succeed(state ? [false, duration, ScheduleDecision.continueWith(Interval.after(now + durationMillis))] : [false, Duration.zero, ScheduleDecision.done]));
+};
+/** @internal */
+export const either = /*#__PURE__*/dual(2, (self, that) => union(self, that));
+/** @internal */
+export const eitherWith = /*#__PURE__*/dual(3, (self, that, f) => unionWith(self, that, f));
+/** @internal */
+export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision.isDone(decision) ? core.as(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
+/** @internal */
+export const exponential = (baseInput, factor = 2.0) => {
+  const base = Duration.decode(baseInput);
+  return delayedSchedule(map(forever, i => Duration.times(base, Math.pow(factor, i))));
+};
+/** @internal */
+export const fibonacci = oneInput => {
+  const one = Duration.decode(oneInput);
+  return delayedSchedule(pipe(unfold([one, one], ([a, b]) => [b, Duration.sum(a, b)]), map(out => out[0])));
+};
+/** @internal */
+export const fixed = intervalInput => {
+  const interval = Duration.decode(intervalInput);
+  const intervalMillis = Duration.toMillis(interval);
+  return makeWithState([Option.none(), 0], (now, _, [option, n]) => core.sync(() => {
+    switch (option._tag) {
+      case "None":
+        {
+          return [[Option.some([now, now + intervalMillis]), n + 1], n, ScheduleDecision.continueWith(Interval.after(now + intervalMillis))];
+        }
+      case "Some":
+        {
+          const [startMillis, lastRun] = option.value;
+          const runningBehind = now > lastRun + intervalMillis;
+          const boundary = Equal.equals(interval, Duration.zero) ? interval : Duration.millis(intervalMillis - (now - startMillis) % intervalMillis);
+          const sleepTime = Equal.equals(boundary, Duration.zero) ? interval : boundary;
+          const nextRun = runningBehind ? now : now + Duration.toMillis(sleepTime);
+          return [[Option.some([startMillis, nextRun]), n + 1], n, ScheduleDecision.continueWith(Interval.after(nextRun))];
+        }
+    }
+  }));
+};
+/** @internal */
+export const fromDelay = delay => duration(delay);
+/** @internal */
+export const fromDelays = (delay, ...delays) => makeWithState([[delay, ...delays].map(_ => Duration.decode(_)), true], (now, _, [durations, cont]) => core.sync(() => {
+  if (cont) {
+    const x = durations[0];
+    const interval = Interval.after(now + Duration.toMillis(x));
+    if (durations.length >= 2) {
+      return [[durations.slice(1), true], x, ScheduleDecision.continueWith(interval)];
+    }
+    const y = durations.slice(1);
+    return [[[x, ...y], false], x, ScheduleDecision.continueWith(interval)];
+  }
+  return [[durations, false], Duration.zero, ScheduleDecision.done];
+}));
+/** @internal */
+export const fromFunction = f => map(identity(), f);
+/** @internal */
+export const hourOfDay = hour => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
+  if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
+    return core.dieSync(() => new core.IllegalArgumentException(`Invalid argument in: hourOfDay(${hour}). Must be in range 0...23`));
+  }
+  const n = state[1];
+  const initial = n === 0;
+  const hour0 = nextHour(now, hour, initial);
+  const start = beginningOfHour(hour0);
+  const end = endOfHour(hour0);
+  const interval = Interval.make(start, end);
+  return core.succeed([[end, n + 1], n, ScheduleDecision.continueWith(interval)]);
+});
+/** @internal */
+export const identity = () => makeWithState(void 0, (now, input, state) => core.succeed([state, input, ScheduleDecision.continueWith(Interval.after(now))]));
+/** @internal */
+export const intersect = /*#__PURE__*/dual(2, (self, that) => intersectWith(self, that, Intervals.intersect));
+/** @internal */
+export const intersectWith = /*#__PURE__*/dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
+  if (ScheduleDecision.isContinue(lDecision) && ScheduleDecision.isContinue(rDecision)) {
+    return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
+  }
+  return core.succeed([[lState, rState], [out, out2], ScheduleDecision.done]);
+}))));
+/** @internal */
+const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, out2, rInterval, f) => {
+  const combined = f(lInterval, rInterval);
+  if (Intervals.isNonEmpty(combined)) {
+    return core.succeed([[lState, rState], [out, out2], ScheduleDecision.continue(combined)]);
+  }
+  if (pipe(lInterval, Intervals.lessThan(rInterval))) {
+    return core.flatMap(self.step(Intervals.end(lInterval), input, lState), ([lState, out, decision]) => {
+      if (ScheduleDecision.isDone(decision)) {
+        return core.succeed([[lState, rState], [out, out2], ScheduleDecision.done]);
+      }
+      return intersectWithLoop(self, that, input, lState, out, decision.intervals, rState, out2, rInterval, f);
+    });
+  }
+  return core.flatMap(that.step(Intervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
+    if (ScheduleDecision.isDone(decision)) {
+      return core.succeed([[lState, rState], [out, out2], ScheduleDecision.done]);
+    }
+    return intersectWithLoop(self, that, input, lState, out, lInterval, rState, out2, decision.intervals, f);
+  });
+};
+/** @internal */
+export const jittered = self => jitteredWith(self, {
+  min: 0.8,
+  max: 1.2
+});
+/** @internal */
+export const jitteredWith = /*#__PURE__*/dual(2, (self, options) => {
+  const {
+    max,
+    min
+  } = Object.assign({
+    min: 0.8,
+    max: 1.2
+  }, options);
+  return delayedEffect(self, duration => core.map(Random.next, random => {
+    const d = Duration.toMillis(duration);
+    const jittered = d * min * (1 - random) + d * max * random;
+    return Duration.millis(jittered);
+  }));
+});
+/** @internal */
+export const linear = baseInput => {
+  const base = Duration.decode(baseInput);
+  return delayedSchedule(map(forever, i => Duration.times(base, i + 1)));
+};
+/** @internal */
+export const map = /*#__PURE__*/dual(2, (self, f) => mapEffect(self, out => core.sync(() => f(out))));
+/** @internal */
+export const mapEffect = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.map(f(out), out2 => [state, out2, decision]))));
+/** @internal */
+export const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
+  if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
+    return core.dieSync(() => new core.IllegalArgumentException(`Invalid argument in: minuteOfHour(${minute}). Must be in range 0...59`));
+  }
+  const n = state[1];
+  const initial = n === 0;
+  const minute0 = nextMinute(now, minute, initial);
+  const start = beginningOfMinute(minute0);
+  const end = endOfMinute(minute0);
+  const interval = Interval.make(start, end);
+  return core.succeed([[end, n + 1], n, ScheduleDecision.continueWith(interval)]);
+});
+/** @internal */
+export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.sync(() => f(out, duration))));
+/** @internal */
+export const modifyDelayEffect = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+  if (ScheduleDecision.isDone(decision)) {
+    return core.succeed([state, out, decision]);
+  }
+  const intervals = decision.intervals;
+  const delay = Interval.size(Interval.make(now, Intervals.start(intervals)));
+  return core.map(f(out, delay), durationInput => {
+    const duration = Duration.decode(durationInput);
+    const oldStart = Intervals.start(intervals);
+    const newStart = now + Duration.toMillis(duration);
+    const delta = newStart - oldStart;
+    const newEnd = Math.min(Math.max(0, Intervals.end(intervals) + delta), Number.MAX_SAFE_INTEGER);
+    const newInterval = Interval.make(newStart, newEnd);
+    return [state, out, ScheduleDecision.continueWith(newInterval)];
+  });
+})));
+/** @internal */
+export const onDecision = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.as(f(out, decision), [state, out, decision]))));
+/** @internal */
+export const passthrough = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), core.map(([state, _, decision]) => [state, input, decision])));
+/** @internal */
+export const provideContext = /*#__PURE__*/dual(2, (self, context) => makeWithState(self.initial, (now, input, state) => core.provideContext(self.step(now, input, state), context)));
+/** @internal */
+export const provideService = /*#__PURE__*/dual(3, (self, tag, service) => makeWithState(self.initial, (now, input, state) => core.contextWithEffect(env => core.provideContext(
+// @ts-expect-error
+self.step(now, input, state), Context.add(env, tag, service)))));
+/** @internal */
+export const recurUntil = f => untilInput(identity(), f);
+/** @internal */
+export const recurUntilEffect = f => untilInputEffect(identity(), f);
+/** @internal */
+export const recurUntilOption = pf => untilOutput(map(identity(), pf), Option.isSome);
+/** @internal */
+export const recurUpTo = durationInput => {
+  const duration = Duration.decode(durationInput);
+  return whileOutput(elapsed, elapsed => Duration.lessThan(elapsed, duration));
+};
+/** @internal */
+export const recurWhile = f => whileInput(identity(), f);
+/** @internal */
+export const recurWhileEffect = f => whileInputEffect(identity(), f);
+/** @internal */
+export const recurs = n => whileOutput(forever, out => out < n);
+/** @internal */
+export const reduce = /*#__PURE__*/dual(3, (self, zero, f) => reduceEffect(self, zero, (z, out) => core.sync(() => f(z, out))));
+/** @internal */
+export const reduceEffect = /*#__PURE__*/dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map(f(z, out), z2 => [[s, z2], z, decision]))));
+/** @internal */
+export const repeatForever = self => makeWithState(self.initial, (now, input, state) => {
+  const step = (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision.isDone(decision) ? step(now, input, self.initial) : core.succeed([state, out, decision]));
+  return step(now, input, state);
+});
+/** @internal */
+export const repetitions = self => reduce(self, 0, (n, _) => n + 1);
+/** @internal */
+export const resetAfter = /*#__PURE__*/dual(2, (self, durationInput) => {
+  const duration = Duration.decode(durationInput);
+  return pipe(self, intersect(elapsed), resetWhen(([, time]) => Duration.greaterThanOrEqualTo(time, duration)), map(out => out[0]));
+});
+/** @internal */
+export const resetWhen = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
+/** @internal */
+export const run = /*#__PURE__*/dual(3, (self, now, input) => pipe(runLoop(self, now, Chunk.fromIterable(input), self.initial, Chunk.empty()), core.map(list => Chunk.reverse(list))));
+/** @internal */
+const runLoop = (self, now, inputs, state, acc) => {
+  if (!Chunk.isNonEmpty(inputs)) {
+    return core.succeed(acc);
+  }
+  const input = Chunk.headNonEmpty(inputs);
+  const nextInputs = Chunk.tailNonEmpty(inputs);
+  return core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+    if (ScheduleDecision.isDone(decision)) {
+      return core.sync(() => pipe(acc, Chunk.prepend(out)));
+    }
+    return runLoop(self, Intervals.start(decision.intervals), nextInputs, state, Chunk.prepend(acc, out));
+  });
+};
+/** @internal */
+export const secondOfMinute = second => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
+  if (!Number.isInteger(second) || second < 0 || 59 < second) {
+    return core.dieSync(() => new core.IllegalArgumentException(`Invalid argument in: secondOfMinute(${second}). Must be in range 0...59`));
+  }
+  const n = state[1];
+  const initial = n === 0;
+  const second0 = nextSecond(now, second, initial);
+  const start = beginningOfSecond(second0);
+  const end = endOfSecond(second0);
+  const interval = Interval.make(start, end);
+  return core.succeed([[end, n + 1], n, ScheduleDecision.continueWith(interval)]);
+});
+/** @internal */
+export const spaced = duration => addDelay(forever, () => duration);
+/** @internal */
+export const succeed = value => map(forever, () => value);
+/** @internal */
+export const sync = evaluate => map(forever, evaluate);
+/** @internal */
+export const tapInput = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.zipRight(f(input), self.step(now, input, state))));
+/** @internal */
+export const tapOutput = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.tap(self.step(now, input, state), ([, out]) => f(out))));
+/** @internal */
+export const unfold = (initial, f) => makeWithState(initial, (now, _, state) => core.sync(() => [f(state), state, ScheduleDecision.continueWith(Interval.after(now))]));
+/** @internal */
+export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that, Intervals.union));
+/** @internal */
+export const unionWith = /*#__PURE__*/dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), ([lState, l, lDecision], [rState, r, rDecision]) => {
+  if (ScheduleDecision.isDone(lDecision) && ScheduleDecision.isDone(rDecision)) {
+    return [[lState, rState], [l, r], ScheduleDecision.done];
+  }
+  if (ScheduleDecision.isDone(lDecision) && ScheduleDecision.isContinue(rDecision)) {
+    return [[lState, rState], [l, r], ScheduleDecision.continue(rDecision.intervals)];
+  }
+  if (ScheduleDecision.isContinue(lDecision) && ScheduleDecision.isDone(rDecision)) {
+    return [[lState, rState], [l, r], ScheduleDecision.continue(lDecision.intervals)];
+  }
+  if (ScheduleDecision.isContinue(lDecision) && ScheduleDecision.isContinue(rDecision)) {
+    const combined = f(lDecision.intervals, rDecision.intervals);
+    return [[lState, rState], [l, r], ScheduleDecision.continue(combined)];
+  }
+  throw new Error("BUG: Schedule.unionWith - please report an issue at https://github.com/Effect-TS/effect/issues");
+})));
+/** @internal */
+export const untilInput = /*#__PURE__*/dual(2, (self, f) => check(self, (input, _) => !f(input)));
+/** @internal */
+export const untilInputEffect = /*#__PURE__*/dual(2, (self, f) => checkEffect(self, (input, _) => effect.negate(f(input))));
+/** @internal */
+export const untilOutput = /*#__PURE__*/dual(2, (self, f) => check(self, (_, out) => !f(out)));
+/** @internal */
+export const untilOutputEffect = /*#__PURE__*/dual(2, (self, f) => checkEffect(self, (_, out) => effect.negate(f(out))));
+/** @internal */
+export const upTo = /*#__PURE__*/dual(2, (self, duration) => zipLeft(self, recurUpTo(duration)));
+/** @internal */
+export const whileInput = /*#__PURE__*/dual(2, (self, f) => check(self, (input, _) => f(input)));
+/** @internal */
+export const whileInputEffect = /*#__PURE__*/dual(2, (self, f) => checkEffect(self, (input, _) => f(input)));
+/** @internal */
+export const whileOutput = /*#__PURE__*/dual(2, (self, f) => check(self, (_, out) => f(out)));
+/** @internal */
+export const whileOutputEffect = /*#__PURE__*/dual(2, (self, f) => checkEffect(self, (_, out) => f(out)));
+/** @internal */
+export const windowed = intervalInput => {
+  const interval = Duration.decode(intervalInput);
+  const millis = Duration.toMillis(interval);
+  return makeWithState([Option.none(), 0], (now, _, [option, n]) => {
+    switch (option._tag) {
+      case "None":
+        {
+          return core.succeed([[Option.some(now), n + 1], n, ScheduleDecision.continueWith(Interval.after(now + millis))]);
+        }
+      case "Some":
+        {
+          return core.succeed([[Option.some(option.value), n + 1], n, ScheduleDecision.continueWith(Interval.after(now + (millis - (now - option.value) % millis)))]);
+        }
+    }
+  });
+};
+/** @internal */
+export const zipLeft = /*#__PURE__*/dual(2, (self, that) => map(intersect(self, that), out => out[0]));
+/** @internal */
+export const zipRight = /*#__PURE__*/dual(2, (self, that) => map(intersect(self, that), out => out[1]));
+/** @internal */
+export const zipWith = /*#__PURE__*/dual(3, (self, that, f) => map(intersect(self, that), ([out, out2]) => f(out, out2)));
+// -----------------------------------------------------------------------------
+// Seconds
+// -----------------------------------------------------------------------------
+/** @internal */
+export const beginningOfSecond = now => {
+  const date = new Date(now);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), 0).getTime();
+};
+/** @internal */
+export const endOfSecond = now => {
+  const date = new Date(beginningOfSecond(now));
+  return date.setSeconds(date.getSeconds() + 1);
+};
+/** @internal */
+export const nextSecond = (now, second, initial) => {
+  const date = new Date(now);
+  if (date.getSeconds() === second && initial) {
+    return now;
+  }
+  if (date.getSeconds() < second) {
+    return date.setSeconds(second);
+  }
+  // Set seconds to the provided value and add one minute
+  const newDate = new Date(date.setSeconds(second));
+  return newDate.setTime(newDate.getTime() + 1000 * 60);
+};
+// -----------------------------------------------------------------------------
+// Minutes
+// -----------------------------------------------------------------------------
+/** @internal */
+export const beginningOfMinute = now => {
+  const date = new Date(now);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), 0, 0).getTime();
+};
+/** @internal */
+export const endOfMinute = now => {
+  const date = new Date(beginningOfMinute(now));
+  return date.setMinutes(date.getMinutes() + 1);
+};
+/** @internal */
+export const nextMinute = (now, minute, initial) => {
+  const date = new Date(now);
+  if (date.getMinutes() === minute && initial) {
+    return now;
+  }
+  if (date.getMinutes() < minute) {
+    return date.setMinutes(minute);
+  }
+  // Set minutes to the provided value and add one hour
+  const newDate = new Date(date.setMinutes(minute));
+  return newDate.setTime(newDate.getTime() + 1000 * 60 * 60);
+};
+// -----------------------------------------------------------------------------
+// Hours
+// -----------------------------------------------------------------------------
+/** @internal */
+export const beginningOfHour = now => {
+  const date = new Date(now);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), 0, 0, 0).getTime();
+};
+/** @internal */
+export const endOfHour = now => {
+  const date = new Date(beginningOfHour(now));
+  return date.setHours(date.getHours() + 1);
+};
+/** @internal */
+export const nextHour = (now, hour, initial) => {
+  const date = new Date(now);
+  if (date.getHours() === hour && initial) {
+    return now;
+  }
+  if (date.getHours() < hour) {
+    return date.setHours(hour);
+  }
+  // Set hours to the provided value and add one day
+  const newDate = new Date(date.setHours(hour));
+  return newDate.setTime(newDate.getTime() + 1000 * 60 * 60 * 24);
+};
+// -----------------------------------------------------------------------------
+// Days
+// -----------------------------------------------------------------------------
+/** @internal */
+export const beginningOfDay = now => {
+  const date = new Date(now);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0).getTime();
+};
+/** @internal */
+export const endOfDay = now => {
+  const date = new Date(beginningOfDay(now));
+  return date.setDate(date.getDate() + 1);
+};
+/** @internal */
+export const nextDay = (now, dayOfWeek, initial) => {
+  const date = new Date(now);
+  if (date.getDay() === dayOfWeek && initial) {
+    return now;
+  }
+  const nextDayOfWeek = (7 + dayOfWeek - date.getDay()) % 7;
+  return date.setDate(date.getDate() + (nextDayOfWeek === 0 ? 7 : nextDayOfWeek));
+};
+/** @internal */
+export const nextDayOfMonth = (now, day, initial) => {
+  const date = new Date(now);
+  if (date.getDate() === day && initial) {
+    return now;
+  }
+  if (date.getDate() < day) {
+    return date.setDate(day);
+  }
+  return findNextMonth(now, day, 1);
+};
+/** @internal */
+export const findNextMonth = (now, day, months) => {
+  const d = new Date(now);
+  const tmp1 = new Date(d.setDate(day));
+  const tmp2 = new Date(tmp1.setMonth(tmp1.getMonth() + months));
+  if (tmp2.getDate() === day) {
+    const d2 = new Date(now);
+    const tmp3 = new Date(d2.setDate(day));
+    return tmp3.setMonth(tmp3.getMonth() + months);
+  }
+  return findNextMonth(now, day, months + 1);
+};
+// circular with Effect
+/** @internal */
+export const repeat_Effect = /*#__PURE__*/dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)));
+/** @internal */
+export const repeatOrElse_Effect = /*#__PURE__*/dual(3, (self, schedule, orElse) => core.flatMap(driver(schedule), driver => core.matchEffect(self, {
+  onFailure: error => orElse(error, Option.none()),
+  onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
+})));
+/** @internal */
+const repeatOrElseEffectLoop = (self, driver, orElse, value) => {
+  return core.matchEffect(driver.next(value), {
+    onFailure: () => core.orDie(driver.last),
+    onSuccess: b => core.matchEffect(self, {
+      onFailure: error => orElse(error, Option.some(b)),
+      onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
+    })
+  });
+};
+/** @internal */
+export const repeatUntil_Effect = /*#__PURE__*/dual(2, (self, f) => repeatUntilEffect_Effect(self, a => core.sync(() => f(a))));
+/** @internal */
+export const repeatUntilEffect_Effect = /*#__PURE__*/dual(2, (self, f) => core.flatMap(self, a => core.flatMap(f(a), result => result ? core.succeed(a) : core.flatMap(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
+/** @internal */
+export const repeatWhile_Effect = /*#__PURE__*/dual(2, (self, f) => repeatWhileEffect_Effect(self, a => core.sync(() => f(a))));
+/** @internal */
+export const repeatWhileEffect_Effect = /*#__PURE__*/dual(2, (self, f) => repeatUntilEffect_Effect(self, a => effect.negate(f(a))));
+/** @internal */
+export const retry_Effect = /*#__PURE__*/dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)));
+/** @internal */
+export const retryN_Effect = /*#__PURE__*/dual(2, (self, n) => retryN_EffectLoop(self, n));
+/** @internal */
+const retryN_EffectLoop = (self, n) => {
+  return core.catchAll(self, e => n <= 0 ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
+};
+/** @internal */
+export const retryOrElse_Effect = /*#__PURE__*/dual(3, (self, policy, orElse) => core.flatMap(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
+/** @internal */
+const retryOrElse_EffectLoop = (self, driver, orElse) => {
+  return core.catchAll(self, e => core.matchEffect(driver.next(e), {
+    onFailure: () => pipe(driver.last, core.orDie, core.flatMap(out => orElse(e, out))),
+    onSuccess: () => retryOrElse_EffectLoop(self, driver, orElse)
+  }));
+};
+/** @internal */
+export const retryUntil_Effect = /*#__PURE__*/dual(2, (self, f) => retryUntilEffect_Effect(self, e => core.sync(() => f(e))));
+/** @internal */
+export const retryUntilEffect_Effect = /*#__PURE__*/dual(2, (self, f) => core.catchAll(self, e => core.flatMap(f(e), b => b ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
+/** @internal */
+export const retryWhile_Effect = /*#__PURE__*/dual(2, (self, f) => retryWhileEffect_Effect(self, e => core.sync(() => f(e))));
+/** @internal */
+export const retryWhileEffect_Effect = /*#__PURE__*/dual(2, (self, f) => retryUntilEffect_Effect(self, e => effect.negate(f(e))));
+/** @internal */
+export const schedule_Effect = /*#__PURE__*/dual(2, (self, schedule) => scheduleFrom_Effect(self, void 0, schedule));
+/** @internal */
+export const scheduleFrom_Effect = /*#__PURE__*/dual(3, (self, initial, schedule) => core.flatMap(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
+/** @internal */
+const scheduleFrom_EffectLoop = (self, initial, driver) => core.matchEffect(driver.next(initial), {
+  onFailure: () => core.orDie(driver.last),
+  onSuccess: () => core.flatMap(self, a => scheduleFrom_EffectLoop(self, a, driver))
+});
+/** @internal */
+export const count = /*#__PURE__*/unfold(0, n => n + 1);
+/** @internal */
+export const elapsed = /*#__PURE__*/makeWithState( /*#__PURE__*/Option.none(), (now, _, state) => {
+  switch (state._tag) {
+    case "None":
+      {
+        return core.succeed([Option.some(now), Duration.zero, ScheduleDecision.continueWith(Interval.after(now))]);
+      }
+    case "Some":
+      {
+        return core.succeed([Option.some(state.value), Duration.millis(now - state.value), ScheduleDecision.continueWith(Interval.after(now))]);
+      }
+  }
+});
+/** @internal */
+export const forever = /*#__PURE__*/unfold(0, n => n + 1);
+/** @internal */
+export const once = /*#__PURE__*/asUnit( /*#__PURE__*/recurs(1));
+/** @internal */
+export const stop = /*#__PURE__*/asUnit( /*#__PURE__*/recurs(0));
+//# sourceMappingURL=schedule.js.map