@fncts/io 0.0.19 → 0.0.21

package/_mjs/Schedule/api.mjs

@@ -17,34 +17,34 @@ import * as tsplus_module_15 from "@fncts/base/collection/immutable/Conc/api";
 import * as tsplus_module_16 from "@fncts/base/collection/immutable/List/constructors";
 import * as tsplus_module_17 from "@fncts/base/collection/immutable/Conc/api/empty";
 export const make = make_1;
-export const addDelay_ = addDelay_1;
-export const addDelayIO_ = addDelayIO_1;
-export const andThenEither_ = andThenEither_1;
-export const as_ = as_1;
-export const check_ = check_1;
-export const checkIO_ = checkIO_1;
-export const contramap_ = contramap_1;
-export const contramapIO_ = contramapIO_1;
+export const addDelay = addDelay_1;
+export const addDelayIO = addDelayIO_1;
+export const andThenEither = andThenEither_1;
+export const as = as_1;
+export const check = check_1;
+export const checkIO = checkIO_1;
+export const contramap = contramap_1;
+export const contramapIO = contramapIO_1;
 export const delayed = delayed_1;
-export const delayedIO_ = delayedIO_1;
+export const delayedIO = delayedIO_1;
 export const either = either_1;
-export const fold_ = fold_1;
-export const foldIO_ = foldIO_1;
+export const fold = fold_1;
+export const foldIO = foldIO_1;
 export const identity = identity_1;
-export const intersectWith_ = intersectWith_1;
-export const map_ = map_1;
-export const mapIO_ = mapIO_1;
-export const modifyDelayIO_ = modifyDelayIO_1;
-export const reconsiderIO_ = reconsiderIO_1;
-export const resetWhen_ = resetWhen_1;
-export const unionWith_ = unionWith_1;
+export const intersectWith = intersectWith_1;
+export const map = map_1;
+export const mapIO = mapIO_1;
+export const modifyDelayIO = modifyDelayIO_1;
+export const reconsiderIO = reconsiderIO_1;
+export const resetWhen = resetWhen_1;
+export const unionWith = unionWith_1;
 export const unfold = unfold_1;
-export const untilInput_ = untilInput_1;
-export const untilInputIO_ = untilInputIO_1;
-export const whileInput_ = whileInput_1;
-export const whileInputIO_ = whileInputIO_1;
-export const whileOutput_ = whileOutput_1;
-export const zip_ = zip_1;
+export const untilInput = untilInput_1;
+export const untilInputIO = untilInputIO_1;
+export const whileInput = whileInput_1;
+export const whileInputIO = whileInputIO_1;
+export const whileOutput = whileOutput_1;
+export const zip = zip_1;
 /**
  * @tsplus static fncts.io.ScheduleOps __call
  */
@@ -60,95 +60,117 @@ 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
  */
 
 
-export function andThen(self, that, __tsplusTrace) {
-  return map_1(andThenEither_1(self, that, __tsplusTrace), out => tsplus_module_3.merge(out), __tsplusTrace);
+export 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_
  */
 
 
-export 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);
+export 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
  */
 
 
-export 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);
+export 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
@@ -156,22 +178,26 @@ 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
  */
 
 
-export function delayedSelf_(self, f, __tsplusTrace) {
-  return delayedIO_1(self, delay => tsplus_module_2.succeed(() => f(delay), __tsplusTrace), __tsplusTrace);
+export 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
@@ -179,24 +205,28 @@ function delayedIO_1(self, f, __tsplusTrace) {
 
 
 export 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
  */
 
-export function dimap_(self, f, g, __tsplusTrace) {
-  return map_1(contramap_1(self, f, __tsplusTrace), g, __tsplusTrace);
+export 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
  */
 
-export function dimapIO_(self, f, g, __tsplusTrace) {
-  return mapIO_1(contramapIO_1(self, f, __tsplusTrace), g, __tsplusTrace);
+export function dimapIO(f, g, __tsplusTrace) {
+  return self => {
+    return mapIO_1(g, __tsplusTrace)(contramapIO_1(f, __tsplusTrace)(self));
+  };
 }
 /**
  * @tsplus static fncts.io.ScheduleOps duration
@@ -213,43 +243,49 @@ export 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
  */
 
 
-export function eitherWith(self, that, f, __tsplusTrace) {
-  return map_1(either_1(self, that, __tsplusTrace), tsplus_module_9.tupled(f), __tsplusTrace);
+export 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");
 export const elapsed = elapsed_1;
 /**
- * @tsplus fluent fncts.io.Schedule ensuring
+ * @tsplus pipeable fncts.io.Schedule ensuring
  */
 
-export 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);
+export 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
  */
 
 export 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
@@ -267,7 +303,7 @@ export function exponential(base, factor = 2, __tsplusTrace) {
  */
 
 export 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]) => {
@@ -276,36 +312,40 @@ export 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
  */
 
 
-export 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);
+export 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");
 export const forever = forever_1;
 /**
  * @tsplus static fncts.io.ScheduleOps identity
@@ -320,33 +360,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
@@ -354,69 +396,83 @@ function intersectWith_1(self, that, f, __tsplusTrace) {
 
 
 export 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
  */
 
 
-export 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);
+export 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
  */
 
-export 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);
+export 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
  */
 
-export function reconsider_(self, f, __tsplusTrace) {
-  return reconsiderIO_1(self, (state, out, decision) => tsplus_module_2.succeed(() => f(state, out, decision), __tsplusTrace), __tsplusTrace);
+export 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
@@ -424,128 +480,140 @@ function reconsiderIO_1(self, f, __tsplusTrace) {
 
 
 export function recurs(n, __tsplusTrace) {
-  return whileOutput_1(forever_1, _ => _ < n, __tsplusTrace);
+  return whileOutput_1(_ => _ < n, __tsplusTrace)(forever_1);
 }
 /**
  * @tsplus static fncts.io.Schedule recurWhile
  */
 
 export 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
  */
 
 export 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
  */
 
 export 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
  */
 
 export 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
  */
 
 export 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
  */
 
 export 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
  */
 
 export 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
  */
 
-export function resetAfter_(self, duration, __tsplusTrace) {
-  return map_1(resetWhen_1(zip_1(self, elapsed_1, __tsplusTrace), ([_, d]) => d >= duration, __tsplusTrace), ([out, _]) => out, __tsplusTrace);
+export 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
  */
 
 
-export 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);
-    }
-  };
+export 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
  */
 
 export function spaced(duration, __tsplusTrace) {
-  return addDelay_1(forever_1, () => duration, __tsplusTrace);
+  return addDelay_1(() => duration, __tsplusTrace)(forever_1);
 }
 /**
  * @tsplus static fncts.io.Schedule succeed
  */
 
 export 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
  */
 
-export 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);
+export 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
  */
 
-export 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);
+export 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
@@ -556,108 +624,132 @@ 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
  */
 
 
-export function untilOutput_(self, f, __tsplusTrace) {
-  return check_1(self, (_, out) => !f(out), __tsplusTrace);
+export 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
  */
 
-export function untilOutputIO_(self, f, __tsplusTrace) {
-  return checkIO_1(self, (_, out) => tsplus_module_2.map_(f(out), b => !b, __tsplusTrace), __tsplusTrace);
+export 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
  */
 
 export 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
  */
 
 
-export function whileOutputIO_(self, f, __tsplusTrace) {
-  return checkIO_1(self, (_, out) => f(out), __tsplusTrace);
+export function whileOutputIO(f, __tsplusTrace) {
+  return self => {
+    return checkIO_1((_, out) => f(out), __tsplusTrace)(self);
+  };
 }
 /**
  * @tsplus static fncts.io.Schedule windowed
  */
 
 export 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
  */
 
 
-export function zipLeft_(self, that, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([out]) => out, __tsplusTrace);
+export 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
  */
 
-export function zipRight_(self, that, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([_, out1]) => out1, __tsplusTrace);
+export 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
  */
 
-export function zipWith_(self, that, f, __tsplusTrace) {
-  return map_1(zip_1(self, that, __tsplusTrace), ([out1, out2]) => f(out1, out2), __tsplusTrace);
+export function zipWith(that, f, __tsplusTrace) {
+  return self => {
+    return map_1(([out1, out2]) => f(out1, out2), __tsplusTrace)(zip_1(that, __tsplusTrace)(self));
+  };
 }
 //# sourceMappingURL=api.mjs.map