@fncts/io 0.0.1

package/_cjs/Schedule/api.cjs

@@ -0,0 +1,790 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDelay_ = exports.addDelayIO_ = void 0;
+exports.andThen = andThen;
+exports.check_ = exports.checkIO_ = exports.as_ = exports.andThenEither_ = void 0;
+exports.compose_ = compose_;
+exports.contramapEnvironment_ = contramapEnvironment_;
+exports.delayedIO_ = exports.delayed = exports.contramap_ = exports.contramapIO_ = void 0;
+exports.delayedSelf_ = delayedSelf_;
+exports.delays = delays;
+exports.dimapIO_ = dimapIO_;
+exports.dimap_ = dimap_;
+exports.duration = duration;
+exports.elapsed = void 0;
+exports.ensuring_ = ensuring_;
+exports.exponential = exponential;
+exports.fixed = fixed;
+exports.forever = exports.fold_ = exports.foldIO_ = void 0;
+exports.foreverSelf = foreverSelf;
+exports.intersectWith_ = exports.identity = void 0;
+exports.linear = linear;
+exports.modifyDelayIO_ = exports.map_ = exports.mapIO_ = exports.make = void 0;
+exports.onDecision_ = onDecision_;
+exports.provideEnvironment_ = provideEnvironment_;
+exports.reconsiderIO_ = void 0;
+exports.reconsider_ = reconsider_;
+exports.recurUntil = recurUntil;
+exports.recurUntilEquals = recurUntilEquals;
+exports.recurUntilIO = recurUntilIO;
+exports.recurWhile = recurWhile;
+exports.recurWhileEquals = recurWhileEquals;
+exports.recurWhileIO = recurWhileIO;
+exports.recurs = recurs;
+exports.repetitions = repetitions;
+exports.resetAfter_ = resetAfter_;
+exports.resetWhen_ = void 0;
+exports.run_ = run_;
+exports.spaced = spaced;
+exports.succeed = succeed;
+exports.tapInput_ = tapInput_;
+exports.tapOutput_ = tapOutput_;
+exports.unfold = void 0;
+exports.unionWith_ = unionWith_;
+exports.untilInput_ = exports.untilInputIO_ = void 0;
+exports.untilOutputIO_ = untilOutputIO_;
+exports.untilOutput_ = untilOutput_;
+exports.upTo = upTo;
+exports.whileInput_ = exports.whileInputIO_ = void 0;
+exports.whileOutputIO_ = whileOutputIO_;
+exports.whileOutput_ = void 0;
+exports.windowed = windowed;
+exports.zipLeft_ = zipLeft_;
+exports.zipRight_ = zipRight_;
+exports.zipWith_ = zipWith_;
+exports.zip_ = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Schedule/definition"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/api"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Schedule/Decision"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Schedule/Interval"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Equatable/api"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/definition"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/constructors"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const fileName_1 = "(@fncts/io) src/Schedule/api.ts";
+const make = make_1;
+exports.make = make;
+const addDelay_ = addDelay_1;
+exports.addDelay_ = addDelay_;
+const addDelayIO_ = addDelayIO_1;
+exports.addDelayIO_ = addDelayIO_;
+const andThenEither_ = andThenEither_1;
+exports.andThenEither_ = andThenEither_;
+const as_ = as_1;
+exports.as_ = as_;
+const check_ = check_1;
+exports.check_ = check_;
+const checkIO_ = checkIO_1;
+exports.checkIO_ = checkIO_;
+const contramap_ = contramap_1;
+exports.contramap_ = contramap_;
+const contramapIO_ = contramapIO_1;
+exports.contramapIO_ = contramapIO_;
+const delayed = delayed_1;
+exports.delayed = delayed;
+const delayedIO_ = delayedIO_1;
+exports.delayedIO_ = delayedIO_;
+const fold_ = fold_1;
+exports.fold_ = fold_;
+const foldIO_ = foldIO_1;
+exports.foldIO_ = foldIO_;
+const identity = identity_1;
+exports.identity = identity;
+const intersectWith_ = intersectWith_1;
+exports.intersectWith_ = intersectWith_;
+const map_ = map_1;
+exports.map_ = map_;
+const mapIO_ = mapIO_1;
+exports.mapIO_ = mapIO_;
+const modifyDelayIO_ = modifyDelayIO_1;
+exports.modifyDelayIO_ = modifyDelayIO_;
+const reconsiderIO_ = reconsiderIO_1;
+exports.reconsiderIO_ = reconsiderIO_;
+const resetWhen_ = resetWhen_1;
+exports.resetWhen_ = resetWhen_;
+const unfold = unfold_1;
+exports.unfold = unfold;
+const untilInput_ = untilInput_1;
+exports.untilInput_ = untilInput_;
+const untilInputIO_ = untilInputIO_1;
+exports.untilInputIO_ = untilInputIO_;
+const whileInput_ = whileInput_1;
+exports.whileInput_ = whileInput_;
+const whileInputIO_ = whileInputIO_1;
+exports.whileInputIO_ = whileInputIO_;
+const whileOutput_ = whileOutput_1;
+exports.whileOutput_ = whileOutput_;
+const zip_ = zip_1;
+/**
+ * @tsplus static fncts.io.ScheduleOps __call
+ */
+
+exports.zip_ = zip_;
+
+function make_1(initial, step) {
+  return new class extends tsplus_module_1.Schedule {
+    constructor() {
+      super(...arguments);
+      this.initial = initial;
+      this.step = step;
+    }
+
+  }();
+}
+/**
+ * @tsplus fluent fncts.io.Schedule addDelay
+ */
+
+
+function addDelay_1(self, f) {
+  return addDelayIO_1(self, out => tsplus_module_2.succeed(() => f(out), fileName_1 + ":27:45"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule addDelayIO
+ */
+
+
+function addDelayIO_1(self, f) {
+  return modifyDelayIO_1(self, (out, duration) => tsplus_module_2.map_(f(out), d => duration + d, fileName_1 + ":37:58"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule andThen
+ */
+
+
+function andThen(self, that) {
+  return map_1(andThenEither_1(self, that), out => tsplus_module_3.merge(out));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule andThenEither
+ */
+
+
+function andThenEither_1(self, that) {
+  return make_1([self.initial, that.initial, true], (now, inp, [s1, s2, onLeft]) => {
+    if (onLeft) {
+      return tsplus_module_2.flatMap_(self.step(now, inp, s1, fileName_1 + ":61:25"), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(that.step(now, inp, s2, fileName_1 + ":65:22"), ([rState, out, decision]) => [[lState, rState, false], tsplus_module_4.right(out), decision], fileName_1 + ":66:21"), interval => tsplus_module_2.succeedNow([[lState, s2, true], tsplus_module_4.left(out), tsplus_module_5.continue_(interval)], fileName_1 + ":67:40")), fileName_1 + ":61:47");
+    } else {
+      return tsplus_module_2.map_(that.step(now, inp, s2, fileName_1 + ":72:16"), ([rState, out, decision]) => [[s1, rState, false], tsplus_module_4.right(out), decision], fileName_1 + ":73:15");
+    }
+  });
+}
+/**
+ * @tsplus fluent fncts.io.Schedule as
+ */
+
+
+function as_1(self, out2) {
+  return map_1(self, () => out2());
+}
+/**
+ * @tsplus fluent fncts.io.Schedule check
+ */
+
+
+function check_1(self, test) {
+  return checkIO_1(self, (inp, out) => tsplus_module_2.succeed(() => test(inp, out), fileName_1 + ":96:47"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule checkIO
+ */
+
+
+function checkIO_1(self, test) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":107:14"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, out, decision], fileName_1 + ":109:28"), interval => tsplus_module_2.map_(test(inp, out), b => b ? [state, out, tsplus_module_5.continue_(interval)] : [state, out, tsplus_module_5.done], fileName_1 + ":111:29")), fileName_1 + ":107:39"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule compose_
+ */
+
+
+function compose_(self, that) {
+  return make_1([self.initial, that.initial], (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state[0], fileName_1 + ":125:14"), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(that.step(now, out, state[1], fileName_1 + ":127:24"), ([rState, out2]) => [[lState, rState], out2, tsplus_module_5.done], fileName_1 + ":127:48"), interval => tsplus_module_2.map_(that.step(now, out, state[1], fileName_1 + ":129:20"), ([rState, out2, decision]) => tsplus_module_5.match_(decision, () => [[lState, rState], out2, tsplus_module_5.done], interval2 => [[lState, rState], out2, tsplus_module_5.continue_(tsplus_module_6.max_(interval, interval2))]), fileName_1 + ":129:44")), fileName_1 + ":125:42"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule contramap
+ */
+
+
+function contramap_1(self, f) {
+  return contramapIO_1(self, inp2 => tsplus_module_2.succeed(() => f(inp2), fileName_1 + ":147:47"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule contramapEnvironment
+ */
+
+
+function contramapEnvironment_(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_7.contramapEnvironment_(self.step(now, inp, state, fileName_1 + ":157:63"), f, fileName_1 + ":157:101"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule contramapIO
+ */
+
+
+function contramapIO_1(self, f) {
+  return make_1(self.initial, (now, inp2, state) => tsplus_module_2.flatMap_(f(inp2), inp => self.step(now, inp, state, fileName_1 + ":167:89"), fileName_1 + ":167:70"));
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps delayed
+ */
+
+
+function delayed_1(schedule) {
+  return addDelay_1(schedule, x => x);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule delayed
+ */
+
+
+function delayedSelf_(self, f) {
+  return delayedIO_1(self, delay => tsplus_module_2.succeed(() => f(delay), fileName_1 + ":184:46"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule delayedIO
+ */
+
+
+function delayedIO_1(self, f) {
+  return modifyDelayIO_1(self, (_, delay) => f(delay));
+}
+/**
+ * @tsplus getter fncts.io.Schedule delays
+ */
+
+
+function delays(self) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":202:14"), ([state, _, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, 0, tsplus_module_5.done], fileName_1 + ":204:28"), interval => {
+    const delay = interval.startMilliseconds - now;
+    return tsplus_module_2.succeedNow([state, delay, tsplus_module_5.continue_(interval)], fileName_1 + ":207:31");
+  }), fileName_1 + ":202:39"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule dimap
+ */
+
+
+function dimap_(self, f, g) {
+  return map_1(contramap_1(self, f), g);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule dimapIO
+ */
+
+
+function dimapIO_(self, f, g) {
+  return mapIO_1(contramapIO_1(self, f), g);
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps duration
+ */
+
+
+function duration(duration) {
+  return make_1(true, (now, _, state) => tsplus_module_2.succeed(() => {
+    if (state) {
+      const interval = tsplus_module_6.after(now + duration);
+      return [false, duration, tsplus_module_5.continue_(interval)];
+    } else {
+      return [false, 0, tsplus_module_5.done];
+    }
+  }, fileName_1 + ":241:15"));
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps elapsed
+ */
+
+
+const elapsed_1 = /*#__PURE__*/make_1( /*#__PURE__*/tsplus_module_8.nothing(), (now, _, state) => tsplus_module_2.succeed(() => tsplus_module_9.match_(state, () => [tsplus_module_8.just(now), 0, tsplus_module_5.continue_(tsplus_module_6.makeInterval(now, Number.MAX_SAFE_INTEGER))], start => {
+  const duration = now - start;
+  return [tsplus_module_8.just(start), duration, tsplus_module_5.continue_(tsplus_module_6.makeInterval(now, Number.MAX_SAFE_INTEGER))];
+}), fileName_1 + ":258:15"));
+const elapsed = elapsed_1;
+/**
+ * @tsplus fluent fncts.io.Schedule ensuring
+ */
+
+exports.elapsed = elapsed;
+
+function ensuring_(self, finalizer) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":277:14"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.as_(finalizer, () => [state, out, tsplus_module_5.done]), interval => tsplus_module_2.succeedNow([state, out, tsplus_module_5.continue_(interval)], fileName_1 + ":280:36")), fileName_1 + ":277:39"));
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps exponential
+ */
+
+
+function exponential(base, factor = 2) {
+  return delayed_1(map_1(forever_1, i => base * Math.pow(factor, i)));
+}
+/**
+ * A schedule that recurs on a fixed interval. Returns the number of
+ * repetitions of the schedule so far.
+ *
+ * If the action run between updates takes longer than the interval, then the
+ * action will be run immediately, but re-runs will not "pile up".
+ *
+ * ```
+ * |-----interval-----|-----interval-----|-----interval-----|
+ * |---------action--------||action|-----|action|-----------|
+ * ```
+ *
+ * @tsplus static fncts.io.ScheduleOps fixed
+ */
+
+
+function fixed(interval) {
+  return make_1([tsplus_module_8.nothing(), 0], (now, inp, [ms, n]) => tsplus_module_2.succeed(() => tsplus_module_9.match_(ms, () => {
+    const nextRun = now + interval;
+    return [[tsplus_module_8.just([now, nextRun]), n + 1], n, tsplus_module_5.continue_(tsplus_module_6.after(nextRun))];
+  }, ([startMillis, lastRun]) => {
+    const runningBehind = now > lastRun + interval;
+    const boundary = interval === 0 ? interval : interval - (now - startMillis) % interval;
+    const sleepTime = boundary === 0 ? interval : boundary;
+    const nextRun = runningBehind ? now : now + sleepTime;
+    return [[tsplus_module_8.just([startMillis, nextRun]), n + 1], n, tsplus_module_5.continue_(tsplus_module_6.after(nextRun))];
+  }), fileName_1 + ":311:15"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule fold
+ */
+
+
+function fold_1(self, z, f) {
+  return foldIO_1(self, z, (z, out) => tsplus_module_2.succeed(() => f(z, out), fileName_1 + ":337:47"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule foldIO
+ */
+
+
+function foldIO_1(self, z, f) {
+  return make_1([self.initial, z], (now, inp, [s, z]) => tsplus_module_2.flatMap_(self.step(now, inp, s, fileName_1 + ":349:14"), ([s, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[s, z], z, tsplus_module_5.done], fileName_1 + ":351:28"), interval => tsplus_module_2.map_(f(z, out), z2 => [[s, z2], z, tsplus_module_5.continue_(interval)], fileName_1 + ":352:36")), fileName_1 + ":349:35"));
+}
+/**
+ * @tsplus getter fncts.io.Schedule forever
+ */
+
+
+function foreverSelf(self) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":363:14"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => self.step(now, inp, self.initial, fileName_1 + ":365:24"), interval => tsplus_module_2.succeed(() => [state, out, tsplus_module_5.continue_(interval)], fileName_1 + ":366:33")), fileName_1 + ":363:39"));
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps forever
+ */
+
+
+const forever_1 = /*#__PURE__*/unfold_1(() => 0, n => n + 1);
+const forever = forever_1;
+/**
+ * @tsplus static fncts.io.ScheduleOps identity
+ */
+
+exports.forever = forever;
+
+function identity_1() {
+  return make_1(undefined, (now, inp, state) => tsplus_module_2.succeed(() => [state, inp, tsplus_module_5.continue_(tsplus_module_6.after(now))], fileName_1 + ":381:61"));
+}
+
+function intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f) {
+  const combined = f(lInterval, rInterval);
+
+  if (tsplus_module_6.isNonEmpty(combined)) {
+    return tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.continue_(combined)], fileName_1 + ":398:25");
+  } else if (tsplus_module_6.lt_(lInterval, rInterval)) {
+    return tsplus_module_2.flatMap_(self.step(lInterval.endMilliseconds, inp, lState, fileName_1 + ":400:21"), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], fileName_1 + ":402:28"), lInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f)), fileName_1 + ":400:69");
+  } else {
+    return tsplus_module_2.flatMap_(that.step(rInterval.endMilliseconds, inp, rState, fileName_1 + ":407:21"), ([rState, out2, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], fileName_1 + ":409:28"), rInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f)), fileName_1 + ":407:69");
+  }
+}
+/**
+ * @tsplus fluent fncts.io.Schedule intersectWith
+ */
+
+
+function intersectWith_1(self, that, f) {
+  return make_1([self.initial, that.initial], (now, inp, state) => {
+    const left = self.step(now, inp, state[0], fileName_1 + ":425:28");
+    const right = that.step(now, inp, state[1], fileName_1 + ":426:28");
+    return tsplus_module_2.flatten(tsplus_module_2.zipWith_(left, right, ([lState, out, lDecision], [rState, out2, rDecision]) => {
+      if (lDecision._tag === "Continue"
+      /* DecisionTag.Continue */
+      && rDecision._tag === "Continue"
+      /* DecisionTag.Continue */
+      ) {
+        return intersectWithLoop(self, that, inp, lState, out, lDecision.interval, rState, out2, rDecision.interval, f);
+      } else {
+        return tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], fileName_1 + ":432:29");
+      }
+    }));
+  });
+}
+/**
+ * @tsplus static fncts.io.Schedule linear
+ */
+
+
+function linear(base) {
+  return delayed_1(map_1(forever_1, i => base * (i + 1)));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule map
+ */
+
+
+function map_1(self, f) {
+  return mapIO_1(self, out => tsplus_module_2.succeedNow(f(out), fileName_1 + ":452:43"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule mapIO
+ */
+
+
+function mapIO_1(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":463:14"), ([state, out, decision]) => tsplus_module_2.map_(f(out), out1 => [state, out1, decision], fileName_1 + ":463:78"), fileName_1 + ":463:39"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule modifyDelayIO
+ */
+
+
+function modifyDelayIO_1(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":475:14"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, out, decision], fileName_1 + ":477:28"), interval => {
+    const delay = tsplus_module_6.size(tsplus_module_6.makeInterval(now, interval.startMilliseconds));
+    return tsplus_module_2.map_(f(out, delay), duration => {
+      const oldStart = interval.startMilliseconds;
+      const newStart = now + duration;
+      const delta = newStart - oldStart;
+      const newEnd = interval.endMilliseconds + delta;
+      const newInterval = tsplus_module_6.makeInterval(newStart, newEnd);
+      return [state, out, tsplus_module_5.continue_(newInterval)];
+    }, fileName_1 + ":481:35");
+  }), fileName_1 + ":475:39"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule onDecision
+ */
+
+
+function onDecision_(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":503:14"), ([state, out, decision]) => tsplus_module_2.as_(f(state, out, decision), () => [state, out, decision]), fileName_1 + ":503:39"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule provideEnvironment
+ */
+
+
+function provideEnvironment_(self, env) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_7.provideEnvironment_(self.step(now, inp, state, fileName_1 + ":514:63"), env, fileName_1 + ":514:99"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule reconsider
+ */
+
+
+function reconsider_(self, f) {
+  return reconsiderIO_1(self, (state, out, decision) => tsplus_module_2.succeed(() => f(state, out, decision), fileName_1 + ":524:64"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule reconsiderIO
+ */
+
+
+function reconsiderIO_1(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":535:14"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(f(state, out, decision), r => tsplus_module_10.match_(r, out1 => [state, out1, tsplus_module_5.done], ([out1, _]) => [state, out1, tsplus_module_5.done]), fileName_1 + ":538:38"), () => tsplus_module_2.map_(f(state, out, decision), r => tsplus_module_10.match_(r, out1 => [state, out1, tsplus_module_5.done], ([out1, interval]) => [state, out1, tsplus_module_5.continue_(interval)]), fileName_1 + ":545:38")), fileName_1 + ":535:39"));
+}
+/**
+ * @tsplus static fncts.io.Schedule recurs
+ */
+
+
+function recurs(n) {
+  return whileOutput_1(forever_1, _ => _ < n);
+}
+/**
+ * @tsplus static fncts.io.Schedule recurWhile
+ */
+
+
+function recurWhile(f) {
+  return whileInput_1(identity_1(), f);
+}
+/**
+ * @tsplus static fncts.io.Schedule recurWhileIO
+ */
+
+
+function recurWhileIO(f) {
+  return whileInputIO_1(identity_1(), f);
+}
+/**
+ * @tsplus static fncts.io.Schedule recurWhileEquals
+ */
+
+
+function recurWhileEquals(value) {
+  return whileInput_1(identity_1(), a => tsplus_module_11.strictEquals(a, value()));
+}
+/**
+ * @tsplus static fncts.io.Schedule recurUntil
+ */
+
+
+function recurUntil(f) {
+  return untilInput_1(identity_1(), f);
+}
+/**
+ * @tsplus static fncts.io.Schedule recurUntilIO
+ */
+
+
+function recurUntilIO(f) {
+  return untilInputIO_1(identity_1(), f);
+}
+/**
+ * @tsplus static fncts.io.Schedule recurUntilEquals
+ */
+
+
+function recurUntilEquals(value) {
+  return untilInput_1(identity_1(), a => tsplus_module_11.strictEquals(a, value()));
+}
+/**
+ * @tsplus getter fncts.io.Schedule repetitions
+ */
+
+
+function repetitions(self) {
+  return fold_1(self, 0, (n, _) => n + 1);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule resetAfter
+ */
+
+
+function resetAfter_(self, duration) {
+  return map_1(resetWhen_1(zip_1(self, elapsed_1), ([_, d]) => d >= duration), ([out, _]) => out);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule resetWhen
+ */
+
+
+function resetWhen_1(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, fileName_1 + ":636:12"), ([state, out, decision]) => f(out) ? self.step(now, inp, self.initial, fileName_1 + ":638:27") : tsplus_module_2.succeedNow([state, out, decision], fileName_1 + ":638:67"), fileName_1 + ":637:15"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule run
+ */
+
+
+function run_(self, now, input) {
+  const loop = (now, xs, state, acc) => {
+    if (tsplus_module_12.isEmpty(xs)) {
+      return tsplus_module_2.succeedNow(acc, fileName_1 + ":653:27");
+    } else {
+      return tsplus_module_2.flatMap_(self.step(now, xs.head, state, fileName_1 + ":655:23"), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeed(() => tsplus_module_13.append_(acc, out), fileName_1 + ":657:27"), interval => loop(interval.startMilliseconds, xs.tail, state, tsplus_module_13.append_(acc, out))), fileName_1 + ":655:52");
+    }
+  };
+
+  return loop(now, tsplus_module_14.from(input), self.initial, tsplus_module_15.empty());
+}
+/**
+ * @tsplus static fncts.io.Schedule spaced
+ */
+
+
+function spaced(duration) {
+  return addDelay_1(forever_1, () => duration);
+}
+/**
+ * @tsplus static fncts.io.Schedule succeed
+ */
+
+
+function succeed(a) {
+  return as_1(forever_1, a);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule tapInput
+ */
+
+
+function tapInput_(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.apSecond_(f(inp), self.step(now, inp, state, fileName_1 + ":687:79"), fileName_1 + ":687:69"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule tapOutput
+ */
+
+
+function tapOutput_(self, f) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.tap_(self.step(now, inp, state, fileName_1 + ":697:63"), ([_, out]) => f(out), fileName_1 + ":697:84"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule unionWith
+ */
+
+
+function unionWith_(self, that, f) {
+  return make_1([self.initial, that.initial], (now, inp, state) => {
+    const left = self.step(now, inp, state[0], fileName_1 + ":709:28");
+    const right = that.step(now, inp, state[1], fileName_1 + ":710:28");
+    return tsplus_module_2.zipWith_(left, right, ([lstate, l, d1], [rstate, r, d2]) => tsplus_module_5.match_(d1, () => tsplus_module_5.match_(d2, () => [[lstate, rstate], [l, r], tsplus_module_5.done], interval => [[lstate, rstate], [l, r], tsplus_module_5.continue_(interval)]), linterval => tsplus_module_5.match_(d2, () => [[lstate, rstate], [l, r], tsplus_module_5.continue_(linterval)], rinterval => {
+      const combined = f(linterval, rinterval);
+      return [[lstate, rstate], [l, r], tsplus_module_5.continue_(combined)];
+    })));
+  });
+}
+/**
+ * @tsplus static fncts.io.ScheduleOps unfold
+ */
+
+
+function unfold_1(a, f) {
+  return make_1(a(), (now, inp, state) => tsplus_module_2.succeed(() => [f(state), state, tsplus_module_5.continue_(tsplus_module_6.makeInterval(now, Number.MAX_SAFE_INTEGER))], fileName_1 + ":737:15"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule untilInput
+ */
+
+
+function untilInput_1(self, f) {
+  return check_1(self, inp => !f(inp));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule untilInputIO
+ */
+
+
+function untilInputIO_1(self, f) {
+  return checkIO_1(self, inp => tsplus_module_2.map_(f(inp), b => !b, fileName_1 + ":758:42"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule untilOutput
+ */
+
+
+function untilOutput_(self, f) {
+  return check_1(self, (_, out) => !f(out));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule untilOutputIO
+ */
+
+
+function untilOutputIO_(self, f) {
+  return checkIO_1(self, (_, out) => tsplus_module_2.map_(f(out), b => !b, fileName_1 + ":778:45"));
+}
+/**
+ * @tsplus static fncts.io.Schedule upTo
+ */
+
+
+function upTo(duration) {
+  return whileOutput_1(elapsed_1, n => n < duration);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule whileInput
+ */
+
+
+function whileInput_1(self, f) {
+  return check_1(self, inp => f(inp));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule whileInputIO
+ */
+
+
+function whileInputIO_1(self, f) {
+  return checkIO_1(self, inp => f(inp));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule whileOutput
+ */
+
+
+function whileOutput_1(self, f) {
+  return check_1(self, (_, out) => f(out));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule whileOutputIO
+ */
+
+
+function whileOutputIO_(self, f) {
+  return checkIO_1(self, (_, out) => f(out));
+}
+/**
+ * @tsplus static fncts.io.Schedule windowed
+ */
+
+
+function windowed(interval) {
+  return make_1([tsplus_module_8.nothing(), 0], (now, inp, [m, n]) => tsplus_module_2.succeed(() => tsplus_module_9.match_(m, () => [[tsplus_module_8.just(now), n + 1], n, tsplus_module_5.continue_(tsplus_module_6.after(now + interval))], startMillis => [[tsplus_module_8.just(startMillis), n + 1], n, tsplus_module_5.continue_(tsplus_module_6.after(now + (interval - (now - startMillis) % interval)))]), fileName_1 + ":835:15"));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule zip
+ */
+
+
+function zip_1(self, that) {
+  return intersectWith_1(self, that, (lInterval, rInterval) => tsplus_module_6.intersect_(lInterval, rInterval));
+}
+/**
+ * @tsplus fluent fncts.io.Schedule zipLeft
+ */
+
+
+function zipLeft_(self, that) {
+  return map_1(zip_1(self, that), ([out]) => out);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule zipRight
+ */
+
+
+function zipRight_(self, that) {
+  return map_1(zip_1(self, that), ([_, out1]) => out1);
+}
+/**
+ * @tsplus fluent fncts.io.Schedule zipWith
+ */
+
+
+function zipWith_(self, that, f) {
+  return map_1(zip_1(self, that), ([out1, out2]) => f(out1, out2));
+}
+//# sourceMappingURL=api.cjs.map