@fncts/io 0.0.20 → 0.0.21

package/_cjs/Schedule/api.cjs

@@ -3,32 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.addDelay_ = exports.addDelayIO_ = void 0;
+exports.addDelayIO = exports.addDelay = 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.checkIO = exports.check = exports.as = exports.andThenEither = void 0;
+exports.compose = compose;
+exports.contramap = void 0;
+exports.contramapEnvironment = contramapEnvironment;
+exports.delayedIO = exports.delayed = exports.contramapIO = void 0;
+exports.delayedSelf = delayedSelf;
 exports.delays = delays;
-exports.dimapIO_ = dimapIO_;
-exports.dimap_ = dimap_;
+exports.dimap = dimap;
+exports.dimapIO = dimapIO;
 exports.duration = duration;
 exports.either = void 0;
 exports.eitherWith = eitherWith;
 exports.elapsed = void 0;
-exports.ensuring_ = ensuring_;
+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.intersectWith = exports.identity = exports.forever = exports.foldIO = exports.fold = 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.modifyDelayIO = exports.mapIO = exports.map = exports.make = void 0;
+exports.onDecision = onDecision;
+exports.provideEnvironment = provideEnvironment;
+exports.reconsider = reconsider;
+exports.reconsiderIO = void 0;
 exports.recurUntil = recurUntil;
 exports.recurUntilEquals = recurUntilEquals;
 exports.recurUntilIO = recurUntilIO;
@@ -36,26 +35,26 @@ exports.recurWhile = recurWhile;
 exports.recurWhileEquals = recurWhileEquals;
 exports.recurWhileIO = recurWhileIO;
 exports.recurs = recurs;
+exports.repeatForever = repeatForever;
 exports.repetitions = repetitions;
-exports.resetAfter_ = resetAfter_;
-exports.resetWhen_ = void 0;
-exports.run_ = run_;
+exports.resetAfter = resetAfter;
+exports.resetWhen = void 0;
+exports.run = run;
 exports.spaced = spaced;
 exports.succeed = succeed;
-exports.tapInput_ = tapInput_;
-exports.tapOutput_ = tapOutput_;
-exports.untilInput_ = exports.untilInputIO_ = exports.unionWith_ = exports.unfold = void 0;
-exports.untilOutputIO_ = untilOutputIO_;
-exports.untilOutput_ = untilOutput_;
+exports.tapInput = tapInput;
+exports.tapOutput = tapOutput;
+exports.untilInputIO = exports.untilInput = exports.unionWith = exports.unfold = void 0;
+exports.untilOutput = untilOutput;
+exports.untilOutputIO = untilOutputIO;
 exports.upTo = upTo;
-exports.whileInput_ = exports.whileInputIO_ = void 0;
-exports.whileOutputIO_ = whileOutputIO_;
-exports.whileOutput_ = void 0;
+exports.whileOutput = exports.whileInputIO = exports.whileInput = void 0;
+exports.whileOutputIO = whileOutputIO;
 exports.windowed = windowed;
-exports.zipLeft_ = zipLeft_;
-exports.zipRight_ = zipRight_;
-exports.zipWith_ = zipWith_;
-exports.zip_ = void 0;
+exports.zip = void 0;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Schedule/definition"));
 
@@ -98,66 +97,66 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 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 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 delayedIO = delayedIO_1;
+exports.delayedIO = delayedIO;
 const either = either_1;
 exports.either = either;
-const fold_ = fold_1;
-exports.fold_ = fold_;
-const foldIO_ = foldIO_1;
-exports.foldIO_ = foldIO_;
+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 unionWith_ = unionWith_1;
-exports.unionWith_ = unionWith_;
+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 unionWith = unionWith_1;
+exports.unionWith = unionWith;
 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;
+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_;
+exports.zip = zip;
 
 function make_1(initial, step, __tsplusTrace) {
   return new class extends tsplus_module_1.Schedule {
@@ -170,98 +169,120 @@ function make_1(initial, step, __tsplusTrace) {
   }();
 }
 /**
- * @tsplus fluent fncts.io.Schedule addDelay
+ * @tsplus pipeable fncts.io.Schedule addDelay
  */
 
 
-function addDelay_1(self, f, __tsplusTrace) {
-  return addDelayIO_1(self, out => tsplus_module_2.succeed(() => f(out), __tsplusTrace), __tsplusTrace);
+function addDelay_1(f, __tsplusTrace) {
+  return self => {
+    return addDelayIO_1(out => tsplus_module_2.succeed(() => f(out), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule addDelayIO
+ * @tsplus pipeable fncts.io.Schedule addDelayIO
  */
 
 
-function addDelayIO_1(self, f, __tsplusTrace) {
-  return modifyDelayIO_1(self, (out, duration) => tsplus_module_2.map_(f(out), d => duration + d, __tsplusTrace), __tsplusTrace);
+function addDelayIO_1(f, __tsplusTrace) {
+  return self => {
+    return modifyDelayIO_1((out, duration) => tsplus_module_2.map(d => duration + d, __tsplusTrace)(f(out)), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule andThen
+ * @tsplus pipeable fncts.io.Schedule andThen
  */
 
 
-function andThen(self, that, __tsplusTrace) {
-  return map_1(andThenEither_1(self, that, __tsplusTrace), out => tsplus_module_3.merge(out), __tsplusTrace);
+function andThen(that, __tsplusTrace) {
+  return self => {
+    return map_1(out => tsplus_module_3.merge(out), __tsplusTrace)(andThenEither_1(that, __tsplusTrace)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule andThenEither
+ * @tsplus pipeable fncts.io.Schedule andThenEither
  */
 
 
-function andThenEither_1(self, that, __tsplusTrace) {
-  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, __tsplusTrace), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(that.step(now, inp, s2, __tsplusTrace), ([rState, out, decision]) => [[lState, rState, false], tsplus_module_4.right(out), decision], __tsplusTrace), interval => tsplus_module_2.succeedNow([[lState, s2, true], tsplus_module_4.left(out), tsplus_module_5.continue_(interval)], __tsplusTrace)), __tsplusTrace);
-    } else {
-      return tsplus_module_2.map_(that.step(now, inp, s2, __tsplusTrace), ([rState, out, decision]) => [[s1, rState, false], tsplus_module_4.right(out), decision], __tsplusTrace);
-    }
-  }, __tsplusTrace);
+function andThenEither_1(that, __tsplusTrace) {
+  return self => {
+    return make_1([self.initial, that.initial, true], (now, inp, [s1, s2, onLeft]) => {
+      if (onLeft) {
+        return tsplus_module_2.flatMap(([lState, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.map(([rState, out, decision]) => [[lState, rState, false], tsplus_module_4.right(out), decision], __tsplusTrace)(that.step(now, inp, s2, __tsplusTrace)), interval => tsplus_module_2.succeedNow([[lState, s2, true], tsplus_module_4.left(out), tsplus_module_5.continue_(interval)], __tsplusTrace))(decision), __tsplusTrace)(self.step(now, inp, s1, __tsplusTrace));
+      } else {
+        return tsplus_module_2.map(([rState, out, decision]) => [[s1, rState, false], tsplus_module_4.right(out), decision], __tsplusTrace)(that.step(now, inp, s2, __tsplusTrace));
+      }
+    }, __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule as
+ * @tsplus pipeable fncts.io.Schedule as
  */
 
 
-function as_1(self, out2, __tsplusTrace) {
-  return map_1(self, () => out2(), __tsplusTrace);
+function as_1(out2, __tsplusTrace) {
+  return self => {
+    return map_1(() => out2(), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule check
+ * @tsplus pipeable fncts.io.Schedule check
  */
 
 
-function check_1(self, test, __tsplusTrace) {
-  return checkIO_1(self, (inp, out) => tsplus_module_2.succeed(() => test(inp, out), __tsplusTrace), __tsplusTrace);
+function check_1(test, __tsplusTrace) {
+  return self => {
+    return checkIO_1((inp, out) => tsplus_module_2.succeed(() => test(inp, out), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule checkIO
+ * @tsplus pipeable fncts.io.Schedule checkIO
  */
 
 
-function checkIO_1(self, test, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), interval => tsplus_module_2.map_(test(inp, out), b => b ? [state, out, tsplus_module_5.continue_(interval)] : [state, out, tsplus_module_5.done], __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function checkIO_1(test, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), interval => tsplus_module_2.map(b => b ? [state, out, tsplus_module_5.continue_(interval)] : [state, out, tsplus_module_5.done], __tsplusTrace)(test(inp, out)))(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule compose_
+ * @tsplus pipeable fncts.io.Schedule compose_
  */
 
 
-function compose_(self, that, __tsplusTrace) {
-  return make_1([self.initial, that.initial], (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state[0], __tsplusTrace), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(that.step(now, out, state[1], __tsplusTrace), ([rState, out2]) => [[lState, rState], out2, tsplus_module_5.done], __tsplusTrace), interval => tsplus_module_2.map_(that.step(now, out, state[1], __tsplusTrace), ([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))]), __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function compose(that, __tsplusTrace) {
+  return self => {
+    return make_1([self.initial, that.initial], (now, inp, state) => tsplus_module_2.flatMap(([lState, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.map(([rState, out2]) => [[lState, rState], out2, tsplus_module_5.done], __tsplusTrace)(that.step(now, out, state[1], __tsplusTrace)), interval => tsplus_module_2.map(([rState, out2, decision]) => tsplus_module_5.match(() => [[lState, rState], out2, tsplus_module_5.done], interval2 => [[lState, rState], out2, tsplus_module_5.continue_(tsplus_module_6.max(interval2)(interval))])(decision), __tsplusTrace)(that.step(now, out, state[1], __tsplusTrace)))(decision), __tsplusTrace)(self.step(now, inp, state[0], __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule contramap
+ * @tsplus pipeable fncts.io.Schedule contramap
  */
 
 
-function contramap_1(self, f, __tsplusTrace) {
-  return contramapIO_1(self, inp2 => tsplus_module_2.succeed(() => f(inp2), __tsplusTrace), __tsplusTrace);
+function contramap_1(f, __tsplusTrace) {
+  return self => {
+    return contramapIO_1(inp2 => tsplus_module_2.succeed(() => f(inp2), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule contramapEnvironment
+ * @tsplus pipeable fncts.io.Schedule contramapEnvironment
  */
 
 
-function contramapEnvironment_(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_7.contramapEnvironment_(self.step(now, inp, state, __tsplusTrace), f, __tsplusTrace), __tsplusTrace);
+function contramapEnvironment(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_7.contramapEnvironment(f, __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule contramapIO
+ * @tsplus pipeable fncts.io.Schedule contramapIO
  */
 
 
-function contramapIO_1(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp2, state) => tsplus_module_2.flatMap_(f(inp2), inp => self.step(now, inp, state, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+function contramapIO_1(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp2, state) => tsplus_module_2.flatMap(inp => self.step(now, inp, state, __tsplusTrace), __tsplusTrace)(f(inp2)), __tsplusTrace);
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps delayed
@@ -269,23 +290,27 @@ function contramapIO_1(self, f, __tsplusTrace) {
 
 
 function delayed_1(schedule, __tsplusTrace) {
-  return addDelay_1(schedule, x => x, __tsplusTrace);
+  return addDelay_1(x => x, __tsplusTrace)(schedule);
 }
 /**
- * @tsplus fluent fncts.io.Schedule delayed
+ * @tsplus pipeable fncts.io.Schedule delayed
  */
 
 
-function delayedSelf_(self, f, __tsplusTrace) {
-  return delayedIO_1(self, delay => tsplus_module_2.succeed(() => f(delay), __tsplusTrace), __tsplusTrace);
+function delayedSelf(f, __tsplusTrace) {
+  return self => {
+    return delayedIO_1(delay => tsplus_module_2.succeed(() => f(delay), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule delayedIO
+ * @tsplus pipeable fncts.io.Schedule delayedIO
  */
 
 
-function delayedIO_1(self, f, __tsplusTrace) {
-  return modifyDelayIO_1(self, (_, delay) => f(delay), __tsplusTrace);
+function delayedIO_1(f, __tsplusTrace) {
+  return self => {
+    return modifyDelayIO_1((_, delay) => f(delay), __tsplusTrace)(self);
+  };
 }
 /**
  * @tsplus getter fncts.io.Schedule delays
@@ -293,26 +318,30 @@ function delayedIO_1(self, f, __tsplusTrace) {
 
 
 function delays(self, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, _, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, 0, tsplus_module_5.done], __tsplusTrace), interval => {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, _, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([state, 0, tsplus_module_5.done], __tsplusTrace), interval => {
     const delay = tsplus_module_6.start(interval) - now;
     return tsplus_module_2.succeedNow([state, delay, tsplus_module_5.continue_(interval)], __tsplusTrace);
-  }), __tsplusTrace), __tsplusTrace);
+  })(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule dimap
+ * @tsplus pipeable fncts.io.Schedule dimap
  */
 
 
-function dimap_(self, f, g, __tsplusTrace) {
-  return map_1(contramap_1(self, f, __tsplusTrace), g, __tsplusTrace);
+function dimap(f, g, __tsplusTrace) {
+  return self => {
+    return map_1(g, __tsplusTrace)(contramap_1(f, __tsplusTrace)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule dimapIO
+ * @tsplus pipeable fncts.io.Schedule dimapIO
  */
 
 
-function dimapIO_(self, f, g, __tsplusTrace) {
-  return mapIO_1(contramapIO_1(self, f, __tsplusTrace), g, __tsplusTrace);
+function dimapIO(f, g, __tsplusTrace) {
+  return self => {
+    return mapIO_1(g, __tsplusTrace)(contramapIO_1(f, __tsplusTrace)(self));
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps duration
@@ -330,40 +359,46 @@ function duration(duration, __tsplusTrace) {
   }, __tsplusTrace), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule either
- * @tsplus operator fncts.io.Schedule ||
+ * @tsplus pipeable fncts.io.Schedule either
+ * @tsplus pipeable-operator fncts.io.Schedule ||
  */
 
 
-function either_1(self, that, __tsplusTrace) {
-  return unionWith_1(self, that, (interval1, interval2) => tsplus_module_6.union(interval1, interval2), __tsplusTrace);
+function either_1(that, __tsplusTrace) {
+  return self => {
+    return unionWith_1(that, (interval1, interval2) => tsplus_module_6.union(interval2)(interval1), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule eitherWith
+ * @tsplus pipeable fncts.io.Schedule eitherWith
  */
 
 
-function eitherWith(self, that, f, __tsplusTrace) {
-  return map_1(either_1(self, that, __tsplusTrace), tsplus_module_9.tupled(f), __tsplusTrace);
+function eitherWith(that, f, __tsplusTrace) {
+  return self => {
+    return map_1(tsplus_module_9.tupled(f), __tsplusTrace)(either_1(that, __tsplusTrace)(self));
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  */
 
 
-const elapsed_1 = /*#__PURE__*/make_1( /*#__PURE__*/tsplus_module_10.nothing(), (now, _, state) => tsplus_module_2.succeed(() => tsplus_module_11.match_(state, () => [tsplus_module_10.just(now), 0, tsplus_module_5.continueWith(tsplus_module_8.makeInterval(now, Number.MAX_SAFE_INTEGER))], start => {
+const elapsed_1 = /*#__PURE__*/make_1( /*#__PURE__*/tsplus_module_10.nothing(), (now, _, state) => tsplus_module_2.succeed(() => tsplus_module_11.match(() => [tsplus_module_10.just(now), 0, tsplus_module_5.continueWith(tsplus_module_8.makeInterval(now, Number.MAX_SAFE_INTEGER))], start => {
   const duration = now - start;
   return [tsplus_module_10.just(start), duration, tsplus_module_5.continueWith(tsplus_module_8.makeInterval(now, Number.MAX_SAFE_INTEGER))];
-}), fileName_1 + ":302:13"), fileName_1 + ":301:91");
+})(state), fileName_1 + ":291:13"), fileName_1 + ":290:91");
 const elapsed = elapsed_1;
 /**
- * @tsplus fluent fncts.io.Schedule ensuring
+ * @tsplus pipeable fncts.io.Schedule ensuring
  */
 
 exports.elapsed = elapsed;
 
-function ensuring_(self, finalizer, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.as_(finalizer, () => [state, out, tsplus_module_5.done], __tsplusTrace), interval => tsplus_module_2.succeedNow([state, out, tsplus_module_5.continue_(interval)], __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function ensuring(finalizer, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.as(() => [state, out, tsplus_module_5.done], __tsplusTrace)(finalizer), interval => tsplus_module_2.succeedNow([state, out, tsplus_module_5.continue_(interval)], __tsplusTrace))(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps exponential
@@ -371,7 +406,7 @@ function ensuring_(self, finalizer, __tsplusTrace) {
 
 
 function exponential(base, factor = 2, __tsplusTrace) {
-  return delayed_1(map_1(forever_1, i => base * Math.pow(factor, i), __tsplusTrace), __tsplusTrace);
+  return delayed_1(map_1(i => base * Math.pow(factor, i), __tsplusTrace)(forever_1), __tsplusTrace);
 }
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
@@ -390,7 +425,7 @@ function exponential(base, factor = 2, __tsplusTrace) {
 
 
 function fixed(interval, __tsplusTrace) {
-  return make_1([tsplus_module_10.nothing(), 0], (now, inp, [ms, n]) => tsplus_module_2.succeed(() => tsplus_module_11.match_(ms, () => {
+  return make_1([tsplus_module_10.nothing(), 0], (now, inp, [ms, n]) => tsplus_module_2.succeed(() => tsplus_module_11.match(() => {
     const nextRun = now + interval;
     return [[tsplus_module_10.just([now, nextRun]), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(nextRun))];
   }, ([startMillis, lastRun]) => {
@@ -399,38 +434,42 @@ function fixed(interval, __tsplusTrace) {
     const sleepTime = boundary === 0 ? interval : boundary;
     const nextRun = runningBehind ? now : now + sleepTime;
     return [[tsplus_module_10.just([startMillis, nextRun]), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(nextRun))];
-  }), __tsplusTrace), __tsplusTrace);
+  })(ms), __tsplusTrace), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule fold
+ * @tsplus pipeable fncts.io.Schedule fold
  */
 
 
-function fold_1(self, z, f, __tsplusTrace) {
-  return foldIO_1(self, z, (z, out) => tsplus_module_2.succeed(() => f(z, out), __tsplusTrace), __tsplusTrace);
+function fold_1(z, f, __tsplusTrace) {
+  return self => {
+    return foldIO_1(z, (z, out) => tsplus_module_2.succeed(() => f(z, out), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule foldIO
+ * @tsplus pipeable fncts.io.Schedule foldIO
  */
 
 
-function foldIO_1(self, z, f, __tsplusTrace) {
-  return make_1([self.initial, z], (now, inp, [s, z]) => tsplus_module_2.flatMap_(self.step(now, inp, s, __tsplusTrace), ([s, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[s, z], z, tsplus_module_5.done], __tsplusTrace), interval => tsplus_module_2.map_(f(z, out), z2 => [[s, z2], z, tsplus_module_5.continue_(interval)], __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function foldIO_1(z, f, __tsplusTrace) {
+  return self => {
+    return make_1([self.initial, z], (now, inp, [s, z]) => tsplus_module_2.flatMap(([s, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([[s, z], z, tsplus_module_5.done], __tsplusTrace), interval => tsplus_module_2.map(z2 => [[s, z2], z, tsplus_module_5.continue_(interval)], __tsplusTrace)(f(z, out)))(decision), __tsplusTrace)(self.step(now, inp, s, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
  * @tsplus getter fncts.io.Schedule forever
  */
 
 
-function foreverSelf(self, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => self.step(now, inp, self.initial, __tsplusTrace), interval => tsplus_module_2.succeed(() => [state, out, tsplus_module_5.continue_(interval)], __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function repeatForever(self, __tsplusTrace) {
+  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => self.step(now, inp, self.initial, __tsplusTrace), interval => tsplus_module_2.succeed(() => [state, out, tsplus_module_5.continue_(interval)], __tsplusTrace))(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
 }
 /**
  * @tsplus static fncts.io.ScheduleOps forever
  */
 
 
-const forever_1 = /*#__PURE__*/unfold_1(() => 0, n => n + 1, fileName_1 + ":430:39");
+const forever_1 = /*#__PURE__*/unfold_1(() => 0, n => n + 1, fileName_1 + ":411:39");
 const forever = forever_1;
 /**
  * @tsplus static fncts.io.ScheduleOps identity
@@ -447,33 +486,35 @@ function intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2
 
   if (tsplus_module_6.isNonEmpty(combined)) {
     return tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.continue_(combined)], __tsplusTrace);
-  } else if (tsplus_module_6.lt(lInterval, rInterval)) {
-    return tsplus_module_2.flatMap_(self.step(tsplus_module_6.end(lInterval), inp, lState, __tsplusTrace), ([lState, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace), lInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f, __tsplusTrace)), __tsplusTrace);
+  } else if (tsplus_module_6.lt(rInterval)(lInterval)) {
+    return tsplus_module_2.flatMap(([lState, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace), lInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f, __tsplusTrace))(decision), __tsplusTrace)(self.step(tsplus_module_6.end(lInterval), inp, lState, __tsplusTrace));
   } else {
-    return tsplus_module_2.flatMap_(that.step(tsplus_module_6.end(rInterval), inp, rState, __tsplusTrace), ([rState, out2, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace), rInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f, __tsplusTrace)), __tsplusTrace);
+    return tsplus_module_2.flatMap(([rState, out2, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace), rInterval => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f, __tsplusTrace))(decision), __tsplusTrace)(that.step(tsplus_module_6.end(rInterval), inp, rState, __tsplusTrace));
   }
 }
 /**
- * @tsplus fluent fncts.io.Schedule intersectWith
+ * @tsplus pipeable fncts.io.Schedule intersectWith
  */
 
 
-function intersectWith_1(self, that, f, __tsplusTrace) {
-  return make_1([self.initial, that.initial], (now, inp, state) => {
-    const left = self.step(now, inp, state[0], __tsplusTrace);
-    const right = that.step(now, inp, state[1], __tsplusTrace);
-    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, __tsplusTrace);
-      } else {
-        return tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace);
-      }
-    }, __tsplusTrace), __tsplusTrace);
-  }, __tsplusTrace);
+function intersectWith_1(that, f, __tsplusTrace) {
+  return self => {
+    return make_1([self.initial, that.initial], (now, inp, state) => {
+      const left = self.step(now, inp, state[0], __tsplusTrace);
+      const right = that.step(now, inp, state[1], __tsplusTrace);
+      return tsplus_module_2.flatten(tsplus_module_2.zipWith(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, __tsplusTrace);
+        } else {
+          return tsplus_module_2.succeedNow([[lState, rState], [out, out2], tsplus_module_5.done], __tsplusTrace);
+        }
+      }, __tsplusTrace)(left), __tsplusTrace);
+    }, __tsplusTrace);
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule linear
@@ -481,73 +522,87 @@ function intersectWith_1(self, that, f, __tsplusTrace) {
 
 
 function linear(base, __tsplusTrace) {
-  return delayed_1(map_1(forever_1, i => base * (i + 1), __tsplusTrace), __tsplusTrace);
+  return delayed_1(map_1(i => base * (i + 1), __tsplusTrace)(forever_1), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule map
+ * @tsplus pipeable fncts.io.Schedule map
  */
 
 
-function map_1(self, f, __tsplusTrace) {
-  return mapIO_1(self, out => tsplus_module_2.succeedNow(f(out), __tsplusTrace), __tsplusTrace);
+function map_1(f, __tsplusTrace) {
+  return self => {
+    return mapIO_1(out => tsplus_module_2.succeedNow(f(out), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule mapIO
+ * @tsplus pipeable fncts.io.Schedule mapIO
  */
 
 
-function mapIO_1(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_2.map_(f(out), out1 => [state, out1, decision], __tsplusTrace), __tsplusTrace), __tsplusTrace);
+function mapIO_1(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_2.map(out1 => [state, out1, decision], __tsplusTrace)(f(out)), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule modifyDelayIO
+ * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  */
 
 
-function modifyDelayIO_1(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), interval => {
-    const delay = tsplus_module_8.size(tsplus_module_8.makeInterval(now, tsplus_module_6.start(interval)));
-    return tsplus_module_2.map_(f(out, delay), duration => {
-      const oldStart = tsplus_module_6.start(interval);
-      const newStart = now + duration;
-      const delta = newStart - oldStart;
-      const newEnd = tsplus_module_6.end(interval) + delta;
-      const newInterval = tsplus_module_8.makeInterval(newStart, newEnd);
-      return [state, out, tsplus_module_5.continueWith(newInterval)];
-    }, __tsplusTrace);
-  }), __tsplusTrace), __tsplusTrace);
+function modifyDelayIO_1(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), interval => {
+      const delay = tsplus_module_8.size(tsplus_module_8.makeInterval(now, tsplus_module_6.start(interval)));
+      return tsplus_module_2.map(duration => {
+        const oldStart = tsplus_module_6.start(interval);
+        const newStart = now + duration;
+        const delta = newStart - oldStart;
+        const newEnd = tsplus_module_6.end(interval) + delta;
+        const newInterval = tsplus_module_8.makeInterval(newStart, newEnd);
+        return [state, out, tsplus_module_5.continueWith(newInterval)];
+      }, __tsplusTrace)(f(out, delay));
+    })(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule onDecision
+ * @tsplus pipeable fncts.io.Schedule onDecision
  */
 
 
-function onDecision_(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_2.as_(f(state, out, decision), () => [state, out, decision], __tsplusTrace), __tsplusTrace), __tsplusTrace);
+function onDecision(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_2.as(() => [state, out, decision], __tsplusTrace)(f(state, out, decision)), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule provideEnvironment
+ * @tsplus pipeable fncts.io.Schedule provideEnvironment
  */
 
 
-function provideEnvironment_(self, env, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_7.provideEnvironment_(self.step(now, inp, state, __tsplusTrace), env, __tsplusTrace), __tsplusTrace);
+function provideEnvironment(env, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_7.provideEnvironment(env, __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule reconsider
+ * @tsplus pipeable fncts.io.Schedule reconsider
  */
 
 
-function reconsider_(self, f, __tsplusTrace) {
-  return reconsiderIO_1(self, (state, out, decision) => tsplus_module_2.succeed(() => f(state, out, decision), __tsplusTrace), __tsplusTrace);
+function reconsider(f, __tsplusTrace) {
+  return self => {
+    return reconsiderIO_1((state, out, decision) => tsplus_module_2.succeed(() => f(state, out, decision), __tsplusTrace), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule reconsiderIO
+ * @tsplus pipeable fncts.io.Schedule reconsiderIO
  */
 
 
-function reconsiderIO_1(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.map_(f(state, out, decision), r => tsplus_module_12.match_(r, out1 => [state, out1, tsplus_module_5.done], ([out1, _]) => [state, out1, tsplus_module_5.done]), __tsplusTrace), () => tsplus_module_2.map_(f(state, out, decision), r => tsplus_module_12.match_(r, out1 => [state, out1, tsplus_module_5.done], ([out1, interval]) => [state, out1, tsplus_module_5.continueWith(interval)]), __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+function reconsiderIO_1(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.map(r => tsplus_module_12.match(out1 => [state, out1, tsplus_module_5.done], ([out1, _]) => [state, out1, tsplus_module_5.done])(r), __tsplusTrace)(f(state, out, decision)), () => tsplus_module_2.map(r => tsplus_module_12.match(out1 => [state, out1, tsplus_module_5.done], ([out1, interval]) => [state, out1, tsplus_module_5.continueWith(interval)])(r), __tsplusTrace)(f(state, out, decision)))(decision), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule recurs
@@ -555,7 +610,7 @@ function reconsiderIO_1(self, f, __tsplusTrace) {
 
 
 function recurs(n, __tsplusTrace) {
-  return whileOutput_1(forever_1, _ => _ < n, __tsplusTrace);
+  return whileOutput_1(_ => _ < n, __tsplusTrace)(forever_1);
 }
 /**
  * @tsplus static fncts.io.Schedule recurWhile
@@ -563,7 +618,7 @@ function recurs(n, __tsplusTrace) {
 
 
 function recurWhile(f, __tsplusTrace) {
-  return whileInput_1(identity_1(__tsplusTrace), f, __tsplusTrace);
+  return whileInput_1(f, __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus static fncts.io.Schedule recurWhileIO
@@ -571,7 +626,7 @@ function recurWhile(f, __tsplusTrace) {
 
 
 function recurWhileIO(f, __tsplusTrace) {
-  return whileInputIO_1(identity_1(__tsplusTrace), f, __tsplusTrace);
+  return whileInputIO_1(f, __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus static fncts.io.Schedule recurWhileEquals
@@ -579,7 +634,7 @@ function recurWhileIO(f, __tsplusTrace) {
 
 
 function recurWhileEquals(value, __tsplusTrace) {
-  return whileInput_1(identity_1(__tsplusTrace), a => tsplus_module_13.strictEquals(a, value()), __tsplusTrace);
+  return whileInput_1(a => tsplus_module_13.strictEquals(a, value()), __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus static fncts.io.Schedule recurUntil
@@ -587,7 +642,7 @@ function recurWhileEquals(value, __tsplusTrace) {
 
 
 function recurUntil(f, __tsplusTrace) {
-  return untilInput_1(identity_1(__tsplusTrace), f, __tsplusTrace);
+  return untilInput_1(f, __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus static fncts.io.Schedule recurUntilIO
@@ -595,7 +650,7 @@ function recurUntil(f, __tsplusTrace) {
 
 
 function recurUntilIO(f, __tsplusTrace) {
-  return untilInputIO_1(identity_1(__tsplusTrace), f, __tsplusTrace);
+  return untilInputIO_1(f, __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus static fncts.io.Schedule recurUntilEquals
@@ -603,7 +658,7 @@ function recurUntilIO(f, __tsplusTrace) {
 
 
 function recurUntilEquals(value, __tsplusTrace) {
-  return untilInput_1(identity_1(__tsplusTrace), a => tsplus_module_13.strictEquals(a, value()), __tsplusTrace);
+  return untilInput_1(a => tsplus_module_13.strictEquals(a, value()), __tsplusTrace)(identity_1(__tsplusTrace));
 }
 /**
  * @tsplus getter fncts.io.Schedule repetitions
@@ -611,39 +666,45 @@ function recurUntilEquals(value, __tsplusTrace) {
 
 
 function repetitions(self, __tsplusTrace) {
-  return fold_1(self, 0, (n, _) => n + 1, __tsplusTrace);
+  return fold_1(0, (n, _) => n + 1, __tsplusTrace)(self);
 }
 /**
- * @tsplus fluent fncts.io.Schedule resetAfter
+ * @tsplus pipeable fncts.io.Schedule resetAfter
  */
 
 
-function resetAfter_(self, duration, __tsplusTrace) {
-  return map_1(resetWhen_1(zip_1(self, elapsed_1, __tsplusTrace), ([_, d]) => d >= duration, __tsplusTrace), ([out, _]) => out, __tsplusTrace);
+function resetAfter(duration, __tsplusTrace) {
+  return self => {
+    return map_1(([out, _]) => out, __tsplusTrace)(resetWhen_1(([_, d]) => d >= duration, __tsplusTrace)(zip_1(elapsed_1, __tsplusTrace)(self)));
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule resetWhen
+ * @tsplus pipeable fncts.io.Schedule resetWhen
  */
 
 
-function resetWhen_1(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap_(self.step(now, inp, state, __tsplusTrace), ([state, out, decision]) => f(out) ? self.step(now, inp, self.initial, __tsplusTrace) : tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), __tsplusTrace), __tsplusTrace);
+function resetWhen_1(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.flatMap(([state, out, decision]) => f(out) ? self.step(now, inp, self.initial, __tsplusTrace) : tsplus_module_2.succeedNow([state, out, decision], __tsplusTrace), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule run
+ * @tsplus pipeable fncts.io.Schedule run
  */
 
 
-function run_(self, now, input, __tsplusTrace) {
-  const loop = (now, xs, state, acc) => {
-    if (tsplus_module_14.isEmpty(xs)) {
-      return tsplus_module_2.succeedNow(acc, __tsplusTrace);
-    } else {
-      return tsplus_module_2.flatMap_(self.step(now, xs.head, state, __tsplusTrace), ([state, out, decision]) => tsplus_module_5.match_(decision, () => tsplus_module_2.succeed(() => tsplus_module_15.append_(acc, out), __tsplusTrace), interval => loop(tsplus_module_6.start(interval), xs.tail, state, tsplus_module_15.append_(acc, out))), __tsplusTrace);
-    }
-  };
+function run(now, input, __tsplusTrace) {
+  return self => {
+    const loop = (now, xs, state, acc) => {
+      if (tsplus_module_14.isEmpty(xs)) {
+        return tsplus_module_2.succeedNow(acc, __tsplusTrace);
+      } else {
+        return tsplus_module_2.flatMap(([state, out, decision]) => tsplus_module_5.match(() => tsplus_module_2.succeed(() => tsplus_module_15.append(out)(acc), __tsplusTrace), interval => loop(tsplus_module_6.start(interval), xs.tail, state, tsplus_module_15.append(out)(acc)))(decision), __tsplusTrace)(self.step(now, xs.head, state, __tsplusTrace));
+      }
+    };
 
-  return loop(now, tsplus_module_16.from(input), self.initial, tsplus_module_17.empty());
+    return loop(now, tsplus_module_16.from(input), self.initial, tsplus_module_17.empty());
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule spaced
@@ -651,7 +712,7 @@ function run_(self, now, input, __tsplusTrace) {
 
 
 function spaced(duration, __tsplusTrace) {
-  return addDelay_1(forever_1, () => duration, __tsplusTrace);
+  return addDelay_1(() => duration, __tsplusTrace)(forever_1);
 }
 /**
  * @tsplus static fncts.io.Schedule succeed
@@ -659,38 +720,44 @@ function spaced(duration, __tsplusTrace) {
 
 
 function succeed(a, __tsplusTrace) {
-  return as_1(forever_1, a, __tsplusTrace);
+  return as_1(a, __tsplusTrace)(forever_1);
 }
 /**
- * @tsplus fluent fncts.io.Schedule tapInput
+ * @tsplus pipeable fncts.io.Schedule tapInput
  */
 
 
-function tapInput_(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.apSecond_(f(inp), self.step(now, inp, state, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+function tapInput(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.apSecond(self.step(now, inp, state, __tsplusTrace), __tsplusTrace)(f(inp)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule tapOutput
+ * @tsplus pipeable fncts.io.Schedule tapOutput
  */
 
 
-function tapOutput_(self, f, __tsplusTrace) {
-  return make_1(self.initial, (now, inp, state) => tsplus_module_2.tap_(self.step(now, inp, state, __tsplusTrace), ([_, out]) => f(out), __tsplusTrace), __tsplusTrace);
+function tapOutput(f, __tsplusTrace) {
+  return self => {
+    return make_1(self.initial, (now, inp, state) => tsplus_module_2.tap(([_, out]) => f(out), __tsplusTrace)(self.step(now, inp, state, __tsplusTrace)), __tsplusTrace);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule unionWith
+ * @tsplus pipeable fncts.io.Schedule unionWith
  */
 
 
-function unionWith_1(self, that, f, __tsplusTrace) {
-  return make_1([self.initial, that.initial], (now, inp, state) => {
-    const left = self.step(now, inp, state[0], __tsplusTrace);
-    const right = that.step(now, inp, state[1], __tsplusTrace);
-    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)];
-    })), __tsplusTrace);
-  }, __tsplusTrace);
+function unionWith_1(that, f, __tsplusTrace) {
+  return self => {
+    return make_1([self.initial, that.initial], (now, inp, state) => {
+      const left = self.step(now, inp, state[0], __tsplusTrace);
+      const right = that.step(now, inp, state[1], __tsplusTrace);
+      return tsplus_module_2.zipWith(right, ([lstate, l, d1], [rstate, r, d2]) => tsplus_module_5.match(() => tsplus_module_5.match(() => [[lstate, rstate], [l, r], tsplus_module_5.done], interval => [[lstate, rstate], [l, r], tsplus_module_5.continue_(interval)])(d2), linterval => tsplus_module_5.match(() => [[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)];
+      })(d2))(d1), __tsplusTrace)(left);
+    }, __tsplusTrace);
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps unfold
@@ -701,36 +768,44 @@ function unfold_1(a, f, __tsplusTrace) {
   return make_1(a(), (now, inp, state) => tsplus_module_2.succeed(() => [f(state), state, tsplus_module_5.continueWith(tsplus_module_8.makeInterval(now, Number.MAX_SAFE_INTEGER))], __tsplusTrace), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule untilInput
+ * @tsplus pipeable fncts.io.Schedule untilInput
  */
 
 
-function untilInput_1(self, f, __tsplusTrace) {
-  return check_1(self, inp => !f(inp), __tsplusTrace);
+function untilInput_1(f, __tsplusTrace) {
+  return self => {
+    return check_1(inp => !f(inp), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule untilInputIO
+ * @tsplus pipeable fncts.io.Schedule untilInputIO
  */
 
 
-function untilInputIO_1(self, f, __tsplusTrace) {
-  return checkIO_1(self, inp => tsplus_module_2.map_(f(inp), b => !b, __tsplusTrace), __tsplusTrace);
+function untilInputIO_1(f, __tsplusTrace) {
+  return self => {
+    return checkIO_1(inp => tsplus_module_2.map(b => !b, __tsplusTrace)(f(inp)), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule untilOutput
+ * @tsplus pipeable fncts.io.Schedule untilOutput
  */
 
 
-function untilOutput_(self, f, __tsplusTrace) {
-  return check_1(self, (_, out) => !f(out), __tsplusTrace);
+function untilOutput(f, __tsplusTrace) {
+  return self => {
+    return check_1((_, out) => !f(out), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule untilOutputIO
+ * @tsplus pipeable fncts.io.Schedule untilOutputIO
  */
 
 
-function untilOutputIO_(self, f, __tsplusTrace) {
-  return checkIO_1(self, (_, out) => tsplus_module_2.map_(f(out), b => !b, __tsplusTrace), __tsplusTrace);
+function untilOutputIO(f, __tsplusTrace) {
+  return self => {
+    return checkIO_1((_, out) => tsplus_module_2.map(b => !b, __tsplusTrace)(f(out)), __tsplusTrace)(self);
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule upTo
@@ -738,39 +813,47 @@ function untilOutputIO_(self, f, __tsplusTrace) {
 
 
 function upTo(duration, __tsplusTrace) {
-  return whileOutput_1(elapsed_1, n => n < duration, __tsplusTrace);
+  return whileOutput_1(n => n < duration, __tsplusTrace)(elapsed_1);
 }
 /**
- * @tsplus fluent fncts.io.Schedule whileInput
+ * @tsplus pipeable fncts.io.Schedule whileInput
  */
 
 
-function whileInput_1(self, f, __tsplusTrace) {
-  return check_1(self, inp => f(inp), __tsplusTrace);
+function whileInput_1(f, __tsplusTrace) {
+  return self => {
+    return check_1(inp => f(inp), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule whileInputIO
+ * @tsplus pipeable fncts.io.Schedule whileInputIO
  */
 
 
-function whileInputIO_1(self, f, __tsplusTrace) {
-  return checkIO_1(self, inp => f(inp), __tsplusTrace);
+function whileInputIO_1(f, __tsplusTrace) {
+  return self => {
+    return checkIO_1(inp => f(inp), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule whileOutput
+ * @tsplus pipeable fncts.io.Schedule whileOutput
  */
 
 
-function whileOutput_1(self, f, __tsplusTrace) {
-  return check_1(self, (_, out) => f(out), __tsplusTrace);
+function whileOutput_1(f, __tsplusTrace) {
+  return self => {
+    return check_1((_, out) => f(out), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule whileOutputIO
+ * @tsplus pipeable fncts.io.Schedule whileOutputIO
  */
 
 
-function whileOutputIO_(self, f, __tsplusTrace) {
-  return checkIO_1(self, (_, out) => f(out), __tsplusTrace);
+function whileOutputIO(f, __tsplusTrace) {
+  return self => {
+    return checkIO_1((_, out) => f(out), __tsplusTrace)(self);
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule windowed
@@ -778,38 +861,46 @@ function whileOutputIO_(self, f, __tsplusTrace) {
 
 
 function windowed(interval, __tsplusTrace) {
-  return make_1([tsplus_module_10.nothing(), 0], (now, inp, [m, n]) => tsplus_module_2.succeed(() => tsplus_module_11.match_(m, () => [[tsplus_module_10.just(now), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(now + interval))], startMillis => [[tsplus_module_10.just(startMillis), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(now + (interval - (now - startMillis) % interval)))]), __tsplusTrace), __tsplusTrace);
+  return make_1([tsplus_module_10.nothing(), 0], (now, inp, [m, n]) => tsplus_module_2.succeed(() => tsplus_module_11.match(() => [[tsplus_module_10.just(now), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(now + interval))], startMillis => [[tsplus_module_10.just(startMillis), n + 1], n, tsplus_module_5.continueWith(tsplus_module_8.after(now + (interval - (now - startMillis) % interval)))])(m), __tsplusTrace), __tsplusTrace);
 }
 /**
- * @tsplus fluent fncts.io.Schedule zip
+ * @tsplus pipeable fncts.io.Schedule zip
  */
 
 
-function zip_1(self, that, __tsplusTrace) {
-  return intersectWith_1(self, that, (lInterval, rInterval) => tsplus_module_6.intersect(lInterval, rInterval), __tsplusTrace);
+function zip_1(that, __tsplusTrace) {
+  return self => {
+    return intersectWith_1(that, (lInterval, rInterval) => tsplus_module_6.intersect(rInterval)(lInterval), __tsplusTrace)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule zipLeft
+ * @tsplus pipeable fncts.io.Schedule zipLeft
  */
 
 
-function zipLeft_(self, that, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([out]) => out, __tsplusTrace);
+function zipLeft(that, __tsplusTrace) {
+  return self => {
+    return map_1(([out]) => out, __tsplusTrace)(zip_1(that, __tsplusTrace)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule zipRight
+ * @tsplus pipeable fncts.io.Schedule zipRight
  */
 
 
-function zipRight_(self, that, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([_, out1]) => out1, __tsplusTrace);
+function zipRight(that, __tsplusTrace) {
+  return self => {
+    return map_1(([_, out1]) => out1, __tsplusTrace)(zip_1(that, __tsplusTrace)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.io.Schedule zipWith
+ * @tsplus pipeable fncts.io.Schedule zipWith
  */
 
 
-function zipWith_(self, that, f, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([out1, out2]) => f(out1, out2), __tsplusTrace);
+function zipWith(that, f, __tsplusTrace) {
+  return self => {
+    return map_1(([out1, out2]) => f(out1, out2), __tsplusTrace)(zip_1(that, __tsplusTrace)(self));
+  };
 }
 //# sourceMappingURL=api.cjs.map