@fncts/io 0.0.20 → 0.0.22

package/_src/Schedule/api.ts

@@ -16,196 +16,195 @@ export function make<State, Env, In, Out>(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule addDelay
+ * @tsplus pipeable fncts.io.Schedule addDelay
  */
-export function addDelay_<State, Env, In, Out>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  f: (out: Out) => number,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env, In, Out> {
-  return self.addDelayIO((out) => IO.succeed(f(out)));
+export function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string) {
+  return <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, Out> => {
+    return self.addDelayIO((out) => IO.succeed(f(out)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule addDelayIO
+ * @tsplus pipeable fncts.io.Schedule addDelayIO
  */
-export function addDelayIO_<State, Env, In, Out, Env1>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  f: (out: Out) => URIO<Env1, number>,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env | Env1, In, Out> {
-  return self.modifyDelayIO((out, duration) => f(out).map((d) => duration + d));
+export function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string) {
+  return <State, Env, In>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<State, Env | Env1, In, Out> => {
+    return self.modifyDelayIO((out, duration) => f(out).map((d) => duration + d));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule andThen
+ * @tsplus pipeable fncts.io.Schedule andThen
  */
-export function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(
-  self: Schedule.WithState<State, Env, In, Out>,
+export function andThen<State1, Env1, In1, Out1>(
   that: Schedule.WithState<State1, Env1, In1, Out1>,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1> {
-  return self.andThenEither(that).map((out) => out.value);
+) {
+  return <State, Env, In, Out>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1> => {
+    return self.andThenEither(that).map((out) => out.value);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule andThenEither
+ * @tsplus pipeable fncts.io.Schedule andThenEither
  */
-export function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(
-  self: Schedule.WithState<State, Env, In, Out>,
+export function andThenEither<State1, Env1, In1, Out1>(
   that: Schedule.WithState<State1, Env1, In1, Out1>,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>> {
-  return Schedule<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>>(
-    [self.initial, that.initial, true],
-    (now, inp, [s1, s2, onLeft]) => {
-      if (onLeft) {
-        return self.step(now, inp, s1).flatMap(([lState, out, decision]) =>
-          decision.match(
-            () =>
-              that
-                .step(now, inp, s2)
-                .map(([rState, out, decision]) => [[lState, rState, false], Either.right(out), decision]),
-            (interval) => IO.succeedNow([[lState, s2, true], Either.left(out), Decision.Continue(interval)]),
-          ),
-        );
-      } else {
-        return that
-          .step(now, inp, s2)
-          .map(([rState, out, decision]) => [[s1, rState, false], Either.right(out), decision]);
-      }
-    },
-  );
+) {
+  return <State, Env, In, Out>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>> => {
+    return Schedule<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>>(
+      [self.initial, that.initial, true],
+      (now, inp, [s1, s2, onLeft]) => {
+        if (onLeft) {
+          return self.step(now, inp, s1).flatMap(([lState, out, decision]) =>
+            decision.match(
+              () =>
+                that
+                  .step(now, inp, s2)
+                  .map(([rState, out, decision]) => [[lState, rState, false], Either.right(out), decision]),
+              (interval) => IO.succeedNow([[lState, s2, true], Either.left(out), Decision.Continue(interval)]),
+            ),
+          );
+        } else {
+          return that
+            .step(now, inp, s2)
+            .map(([rState, out, decision]) => [[s1, rState, false], Either.right(out), decision]);
+        }
+      },
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule as
+ * @tsplus pipeable fncts.io.Schedule as
  */
-export function as_<State, Env, In, Out, Out2>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  out2: Lazy<Out2>,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env, In, Out2> {
-  return self.map(() => out2());
+export function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string) {
+  return <State, Env, In, Out>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<State, Env, In, Out2> => {
+    return self.map(() => out2());
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule check
+ * @tsplus getter fncts.io.Schedule asUnit
  */
-export function check_<State, Env, In, Out>(
+export function asUnit<State, Env, In, Out>(
   self: Schedule.WithState<State, Env, In, Out>,
-  test: (inp: In, out: Out) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env, In, Out> {
-  return self.checkIO((inp, out) => IO.succeed(test(inp, out)));
+): Schedule.WithState<State, Env, In, void> {
+  return self.as(undefined);
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule checkIO
+ * @tsplus pipeable fncts.io.Schedule check
  */
-export function checkIO_<State, Env, In, Out, Env1>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  test: (inp: In, out: Out) => URIO<Env1, boolean>,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env | Env1, In, Out> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) =>
-      decision.match(
-        () => IO.succeedNow([state, out, decision]),
-        (interval) =>
-          test(inp, out).map((b) => (b ? [state, out, Decision.Continue(interval)] : [state, out, Decision.Done])),
+export function check<In, Out>(test: (inp: In, out: Out) => boolean, __tsplusTrace?: string) {
+  return <State, Env>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, Out> => {
+    return self.checkIO((inp, out) => IO.succeed(test(inp, out)));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Schedule checkIO
+ */
+export function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, boolean>, __tsplusTrace?: string) {
+  return <State, Env>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<State, Env | Env1, In, Out> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self.step(now, inp, state).flatMap(([state, out, decision]) =>
+        decision.match(
+          () => IO.succeedNow([state, out, decision]),
+          (interval) =>
+            test(inp, out).map((b) => (b ? [state, out, Decision.Continue(interval)] : [state, out, Decision.Done])),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule compose_
+ * @tsplus pipeable fncts.io.Schedule compose_
  */
-export function compose_<S, R, I, O, S1, R1, O2>(
-  self: Schedule.WithState<S, R, I, O>,
-  that: Schedule.WithState<S1, R1, O, O2>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I, O2> {
-  return Schedule([self.initial, that.initial], (now, inp, state) =>
-    self.step(now, inp, state[0]).flatMap(([lState, out, decision]) =>
-      decision.match(
-        () => that.step(now, out, state[1]).map(([rState, out2]) => [[lState, rState], out2, Decision.Done]),
-        (interval) =>
-          that.step(now, out, state[1]).map(([rState, out2, decision]) =>
-            decision.match(
-              () => [[lState, rState], out2, Decision.Done],
-              (interval2) => [[lState, rState], out2, Decision.Continue(interval.max(interval2))],
+export function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, S1], R | R1, I, O2> => {
+    return Schedule([self.initial, that.initial], (now, inp, state) =>
+      self.step(now, inp, state[0]).flatMap(([lState, out, decision]) =>
+        decision.match(
+          () => that.step(now, out, state[1]).map(([rState, out2]) => [[lState, rState], out2, Decision.Done]),
+          (interval) =>
+            that.step(now, out, state[1]).map(([rState, out2, decision]) =>
+              decision.match(
+                () => [[lState, rState], out2, Decision.Done],
+                (interval2) => [[lState, rState], out2, Decision.Continue(interval.max(interval2))],
+              ),
             ),
-          ),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule contramap
+ * @tsplus pipeable fncts.io.Schedule contramap
  */
-export function contramap_<S, R, I, O, I2>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I2) => I,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I2, O> {
-  return self.contramapIO((inp2) => IO.succeed(f(inp2)));
+export function contramap<I, I2>(f: (inp: I2) => I, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I2, O> => {
+    return self.contramapIO((inp2) => IO.succeed(f(inp2)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule contramapEnvironment
+ * @tsplus pipeable fncts.io.Schedule contramapEnvironment
  */
-export function contramapEnvironment_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (env: Environment<R1>) => Environment<R>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R1, I, O> {
-  return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).contramapEnvironment(f));
+export function contramapEnvironment<R, R1>(f: (env: Environment<R1>) => Environment<R>, __tsplusTrace?: string) {
+  return <S, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R1, I, O> => {
+    return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).contramapEnvironment(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule contramapIO
+ * @tsplus pipeable fncts.io.Schedule contramapIO
  */
-export function contramapIO_<S, R, I, O, R1, I2>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I2) => URIO<R1, I>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I2, O> {
-  return Schedule(self.initial, (now, inp2, state) => f(inp2).flatMap((inp) => self.step(now, inp, state)));
+export function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I2, O> => {
+    return Schedule(self.initial, (now, inp2, state) => f(inp2).flatMap((inp) => self.step(now, inp, state)));
+  };
 }
 
 /**
  * @tsplus static fncts.io.ScheduleOps delayed
  */
 export function delayed<S, R, I>(
-  schedule: Schedule.WithState<S, R, I, number>,
+  schedule: Schedule.WithState<S, R, I, Duration>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, number> {
+): Schedule.WithState<S, R, I, Duration> {
   return schedule.addDelay((x) => x);
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule delayed
+ * @tsplus pipeable fncts.io.Schedule delayed
  */
-export function delayedSelf_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (delay: number) => number,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return self.delayedIO((delay) => IO.succeed(f(delay)));
+export function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string) {
+  return <S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return self.delayedIO((delay) => IO.succeed(f(delay)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule delayedIO
+ * @tsplus pipeable fncts.io.Schedule delayedIO
  */
-export function delayedIO_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (delay: number) => URIO<R1, number>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return self.modifyDelayIO((_, delay) => f(delay));
+export function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string) {
+  return <S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return self.modifyDelayIO((_, delay) => f(delay));
+  };
 }
 
 /**
@@ -229,113 +228,112 @@ export function delays<S, R, I, O>(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule dimap
+ * @tsplus pipeable fncts.io.Schedule dimap
  */
-export function dimap_<S, R, I, O, I2, O2>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp2: I2) => I,
-  g: (out: O) => O2,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I2, O2> {
-  return self.contramap(f).map(g);
+export function dimap<I, O, I2, O2>(f: (inp2: I2) => I, g: (out: O) => O2, __tsplusTrace?: string) {
+  return <S, R>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I2, O2> => {
+    return self.contramap(f).map(g);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule dimapIO
+ * @tsplus pipeable fncts.io.Schedule dimapIO
  */
-export function dimapIO_<S, R, I, O, R1, I2, R2, O2>(
-  self: Schedule.WithState<S, R, I, O>,
+export function dimapIO<I, O, R1, I2, R2, O2>(
   f: (inp2: I2) => URIO<R1, I>,
   g: (out: O) => URIO<R2, O2>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1 | R2, I2, O2> {
-  return self.contramapIO(f).mapIO(g);
+) {
+  return <S, R>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1 | R2, I2, O2> => {
+    return self.contramapIO(f).mapIO(g);
+  };
 }
 
 /**
  * @tsplus static fncts.io.ScheduleOps duration
  */
 export function duration(
-  duration: number,
+  duration: Duration,
   __tsplusTrace?: string,
-): Schedule.WithState<boolean, never, unknown, number> {
-  return Schedule<boolean, never, unknown, number>(true, (now, _, state) =>
+): Schedule.WithState<boolean, never, unknown, Duration> {
+  return Schedule<boolean, never, unknown, Duration>(true, (now, _, state) =>
     IO.succeed(() => {
       if (state) {
-        const interval = Interval.after(now + duration);
+        const interval = Interval.after(now + duration.milliseconds);
         return [false, duration, Decision.continueWith(interval)];
       } else {
-        return [false, 0, Decision.Done];
+        return [false, Duration.zero, Decision.Done];
       }
     }),
   );
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule either
- * @tsplus operator fncts.io.Schedule ||
+ * @tsplus pipeable fncts.io.Schedule either
+ * @tsplus pipeable-operator fncts.io.Schedule ||
  */
-export function either<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
-  that: Schedule.WithState<S1, R1, I1, O1>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
-  return self.unionWith(that, (interval1, interval2) => interval1 || interval2);
+export function either<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> => {
+    return self.unionWith(that, (interval1, interval2) => interval1 || interval2);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule eitherWith
+ * @tsplus pipeable fncts.io.Schedule eitherWith
  */
-export function eitherWith<S, R, I, O, S1, R1, I1, O1, O2>(
-  self: Schedule.WithState<S, R, I, O>,
+export function eitherWith<O, S1, R1, I1, O1, O2>(
   that: Schedule.WithState<S1, R1, I1, O1>,
   f: (out1: O, out2: O1) => O2,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2> {
-  return (self || that).map(f.tupled);
+) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2> => {
+    return (self || that).map(f.tupled);
+  };
 }
 
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  */
-export const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number> = Schedule(Nothing(), (now, _, state) =>
-  IO.succeed(
-    state.match(
-      () => [Just(now), 0, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))],
-      (start) => {
-        const duration = now - start;
-        return [Just(start), duration, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))];
-      },
+export const elapsed: Schedule.WithState<Maybe<number>, never, unknown, Duration> = Schedule(
+  Nothing(),
+  (now, _, state) =>
+    IO.succeed(
+      state.match(
+        () => [Just(now), Duration.zero, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))],
+        (start) => {
+          const duration = Duration.fromInterval(start, now);
+          return [Just(start), duration, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))];
+        },
+      ),
     ),
-  ),
 );
 
 /**
- * @tsplus fluent fncts.io.Schedule ensuring
+ * @tsplus pipeable fncts.io.Schedule ensuring
  */
-export function ensuring_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  finalizer: UIO<any>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) =>
-      decision.match(
-        () => finalizer.as([state, out, Decision.Done]),
-        (interval) => IO.succeedNow([state, out, Decision.Continue(interval)]),
+export function ensuring(finalizer: UIO<any>, __tsplusTrace?: string) {
+  return <S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self.step(now, inp, state).flatMap(([state, out, decision]) =>
+        decision.match(
+          () => finalizer.as([state, out, Decision.Done]),
+          (interval) => IO.succeedNow([state, out, Decision.Continue(interval)]),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
  * @tsplus static fncts.io.ScheduleOps exponential
  */
 export function exponential(
-  base: number,
+  base: Duration,
   factor = 2,
   __tsplusTrace?: string,
-): Schedule.WithState<number, never, unknown, number> {
+): Schedule.WithState<number, never, unknown, Duration> {
   return Schedule.delayed(Schedule.forever.map((i) => base * Math.pow(factor, i)));
 }
 
@@ -354,20 +352,21 @@ export function exponential(
  * @tsplus static fncts.io.ScheduleOps fixed
  */
 export function fixed(
-  interval: number,
+  interval: Duration,
   __tsplusTrace?: string,
 ): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number> {
+  const intervalMillis = interval.milliseconds;
   return Schedule([Nothing(), 0], (now, inp, [ms, n]) =>
     IO.succeed(
       ms.match(
         () => {
-          const nextRun = now + interval;
+          const nextRun = now + intervalMillis;
           return [[Just([now, nextRun]), n + 1], n, Decision.continueWith(Interval.after(nextRun))];
         },
         ([startMillis, lastRun]) => {
-          const runningBehind = now > lastRun + interval;
-          const boundary      = interval === 0 ? interval : interval - ((now - startMillis) % interval);
-          const sleepTime     = boundary === 0 ? interval : boundary;
+          const runningBehind = now > lastRun + intervalMillis;
+          const boundary      = intervalMillis === 0 ? intervalMillis : intervalMillis - ((now - startMillis) % intervalMillis);
+          const sleepTime     = boundary === 0 ? intervalMillis : boundary;
           const nextRun       = runningBehind ? now : now + sleepTime;
           return [[Just([startMillis, nextRun]), n + 1], n, Decision.continueWith(Interval.after(nextRun))];
         },
@@ -377,40 +376,34 @@ export function fixed(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule fold
+ * @tsplus pipeable fncts.io.Schedule fold
  */
-export function fold_<S, R, I, O, Z>(
-  self: Schedule.WithState<S, R, I, O>,
-  z: Z,
-  f: (z: Z, out: O) => Z,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, Z], R, I, Z> {
-  return self.foldIO(z, (z, out) => IO.succeed(f(z, out)));
+export function fold<O, Z>(z: Z, f: (z: Z, out: O) => Z, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, Z], R, I, Z> => {
+    return self.foldIO(z, (z, out) => IO.succeed(f(z, out)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule foldIO
+ * @tsplus pipeable fncts.io.Schedule foldIO
  */
-export function foldIO_<S, R, I, O, Z, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  z: Z,
-  f: (z: Z, out: O) => URIO<R1, Z>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, Z], R | R1, I, Z> {
-  return Schedule([self.initial, z], (now, inp, [s, z]) =>
-    self.step(now, inp, s).flatMap(([s, out, decision]) =>
-      decision.match(
-        () => IO.succeedNow([[s, z], z, Decision.Done]),
-        (interval) => f(z, out).map((z2) => [[s, z2], z, Decision.Continue(interval)]),
+export function foldIO<O, Z, R1>(z: Z, f: (z: Z, out: O) => URIO<R1, Z>, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, Z], R | R1, I, Z> => {
+    return Schedule([self.initial, z], (now, inp, [s, z]) =>
+      self.step(now, inp, s).flatMap(([s, out, decision]) =>
+        decision.match(
+          () => IO.succeedNow([[s, z], z, Decision.Done]),
+          (interval) => f(z, out).map((z2) => [[s, z2], z, Decision.Continue(interval)]),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
  * @tsplus getter fncts.io.Schedule forever
  */
-export function foreverSelf<S, R, I, O>(
+export function repeatForever<S, R, I, O>(
   self: Schedule.WithState<S, R, I, O>,
   __tsplusTrace?: string,
 ): Schedule.WithState<S, R, I, O> {
@@ -470,169 +463,195 @@ function intersectWithLoop<S, R, I, O, S1, R1, I1, O1>(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule intersectWith
+ * @tsplus pipeable fncts.io.Schedule intersectWith
  */
-export function intersectWith_<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
+export function intersectWith<S1, R1, I1, O1>(
   that: Schedule.WithState<S1, R1, I1, O1>,
   f: (int1: Intervals, int2: Intervals) => Intervals,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
-  return Schedule([self.initial, that.initial] as const, (now, inp, state) => {
-    const left  = self.step(now, inp, state[0]);
-    const right = that.step(now, inp, state[1]);
-
-    return left.zipWith(right, ([lState, out, lDecision], [rState, out2, rDecision]) => {
-      if (lDecision._tag === DecisionTag.Continue && rDecision._tag === DecisionTag.Continue) {
-        return intersectWithLoop(self, that, inp, lState, out, lDecision.interval, rState, out2, rDecision.interval, f);
-      } else {
-        return IO.succeedNow([[lState, rState], [out, out2], Decision.Done] as const);
-      }
-    }).flatten;
-  });
+) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> => {
+    return Schedule([self.initial, that.initial] as const, (now, inp, state) => {
+      const left  = self.step(now, inp, state[0]);
+      const right = that.step(now, inp, state[1]);
+      return left.zipWith(right, ([lState, out, lDecision], [rState, out2, rDecision]) => {
+        if (lDecision._tag === DecisionTag.Continue && rDecision._tag === DecisionTag.Continue) {
+          return intersectWithLoop(
+            self,
+            that,
+            inp,
+            lState,
+            out,
+            lDecision.interval,
+            rState,
+            out2,
+            rDecision.interval,
+            f,
+          );
+        } else {
+          return IO.succeedNow([[lState, rState], [out, out2], Decision.Done] as const);
+        }
+      }).flatten;
+    });
+  };
 }
 
 /**
  * @tsplus static fncts.io.Schedule linear
  */
-export function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
+export function linear(base: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration> {
   return Schedule.delayed(Schedule.forever.map((i) => base * (i + 1)));
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule map
+ * @tsplus pipeable fncts.io.Schedule map
  */
-export function map_<State, Env, In, Out, Out1>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  f: (out: Out) => Out1,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env, In, Out1> {
-  return self.mapIO((out) => IO.succeedNow(f(out)));
+export function map<Out, Out1>(f: (out: Out) => Out1, __tsplusTrace?: string) {
+  return <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, Out1> => {
+    return self.mapIO((out) => IO.succeedNow(f(out)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule mapIO
+ * @tsplus pipeable fncts.io.Schedule mapIO
  */
-export function mapIO_<State, Env, In, Out, Env1, Out1>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  f: (out: Out) => URIO<Env1, Out1>,
-  __tsplusTrace?: string,
-): Schedule.WithState<State, Env | Env1, In, Out1> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) => f(out).map((out1) => [state, out1, decision])),
-  );
+export function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>, __tsplusTrace?: string) {
+  return <State, Env, In>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<State, Env | Env1, In, Out1> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self.step(now, inp, state).flatMap(([state, out, decision]) => f(out).map((out1) => [state, out1, decision])),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule modifyDelayIO
+ * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  */
-export function modifyDelayIO_<State, Env, In, Out, Env1>(
-  self: Schedule.WithState<State, Env, In, Out>,
-  f: (out: Out, duration: number) => URIO<Env1, number>,
+export function modifyDelayIO<Out, Env1>(
+  f: (out: Out, duration: Duration) => URIO<Env1, Duration>,
   __tsplusTrace?: string,
-): Schedule.WithState<State, Env | Env1, In, Out> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) =>
-      decision.match(
-        () => IO.succeedNow([state, out, decision]),
-        (interval) => {
-          const delay = Interval(now, interval.start).size;
-
-          return f(out, delay).map((duration) => {
-            const oldStart    = interval.start;
-            const newStart    = now + duration;
-            const delta       = newStart - oldStart;
-            const newEnd      = interval.end + delta;
-            const newInterval = Interval(newStart, newEnd);
-            return [state, out, Decision.continueWith(newInterval)];
-          });
-        },
+) {
+  return <State, Env, In>(
+    self: Schedule.WithState<State, Env, In, Out>,
+  ): Schedule.WithState<State, Env | Env1, In, Out> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self.step(now, inp, state).flatMap(([state, out, decision]) =>
+        decision.match(
+          () => IO.succeedNow([state, out, decision]),
+          (interval) => {
+            const delay = Interval(now, interval.start).size;
+            return f(out, delay).map((duration) => {
+              const oldStart    = interval.start;
+              const newStart    = now + duration.milliseconds;
+              const delta       = newStart - oldStart;
+              const newEnd      = interval.end + delta;
+              const newInterval = Interval(newStart, newEnd);
+              return [state, out, Decision.continueWith(newInterval)];
+            });
+          },
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule onDecision
+ * @tsplus static fncts.io.ScheduleOps once
  */
-export function onDecision_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
+export const once: Schedule.WithState<number, never, any, void> = Schedule.recurs(1).asUnit;
+
+/**
+ * @tsplus static fncts.io.ScheduleOps asap
+ */
+export const asap = Schedule.once.delayed(() => (0).milliseconds);
+
+/**
+ * @tsplus pipeable fncts.io.Schedule onDecision
+ */
+export function onDecision<S, O, R1>(
   f: (state: S, out: O, decision: Decision) => URIO<R1, any>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) => f(state, out, decision).as([state, out, decision])),
-  );
+) {
+  return <R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self
+        .step(now, inp, state)
+        .flatMap(([state, out, decision]) => f(state, out, decision).as([state, out, decision])),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule provideEnvironment
+ * @tsplus pipeable fncts.io.Schedule provideEnvironment
  */
-export function provideEnvironment_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  env: Environment<R>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, never, I, O> {
-  return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).provideEnvironment(env));
+export function provideEnvironment<R>(env: Environment<R>, __tsplusTrace?: string) {
+  return <S, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, never, I, O> => {
+    return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).provideEnvironment(env));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule reconsider
+ * @tsplus pipeable fncts.io.Schedule reconsider
  */
-export function reconsider_<S, R, I, O, O2>(
-  self: Schedule.WithState<S, R, I, O>,
+export function reconsider<S, O, O2>(
   f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O2> {
-  return self.reconsiderIO((state, out, decision) => IO.succeed(f(state, out, decision)));
+) {
+  return <R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O2> => {
+    return self.reconsiderIO((state, out, decision) => IO.succeed(f(state, out, decision)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule reconsiderIO
+ * @tsplus pipeable fncts.io.Schedule reconsiderIO
  */
-export function reconsiderIO_<S, R, I, O, R1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
+export function reconsiderIO<S, O, R1, O1>(
   f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>,
   __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O1> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self.step(now, inp, state).flatMap(([state, out, decision]) =>
-      decision.match(
-        () =>
-          f(state, out, decision).map((r) =>
-            r.match(
-              (out1) => [state, out1, Decision.Done],
-              ([out1, _]) => [state, out1, Decision.Done],
+) {
+  return <R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O1> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self.step(now, inp, state).flatMap(([state, out, decision]) =>
+        decision.match(
+          () =>
+            f(state, out, decision).map((r) =>
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, _]) => [state, out1, Decision.Done],
+              ),
             ),
-          ),
-        () =>
-          f(state, out, decision).map((r) =>
-            r.match(
-              (out1) => [state, out1, Decision.Done],
-              ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+          () =>
+            f(state, out, decision).map((r) =>
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+              ),
             ),
-          ),
+        ),
       ),
-    ),
-  );
+    );
+  };
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurs
+ * @tsplus static fncts.io.ScheduleOps recurs
  */
 export function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.whileOutput((_) => _ < n);
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus static fncts.io.ScheduleOps recurWhile
  */
 export function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
   return identity<A>().whileInput(f);
 }
 
 /**
- * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus static fncts.io.ScheduleOps recurWhileIO
  */
 export function recurWhileIO<R, A>(
   f: (a: A) => URIO<R, boolean>,
@@ -683,64 +702,59 @@ export function repetitions<S, R, I, O>(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule resetAfter
+ * @tsplus pipeable fncts.io.Schedule resetAfter
  */
-export function resetAfter_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  duration: number,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, Maybe<number>], R, I, O> {
-  return self
-    .zip(Schedule.elapsed)
-    .resetWhen(([_, d]) => d >= duration)
-    .map(([out, _]) => out);
+export function resetAfter(duration: Duration, __tsplusTrace?: string) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, Maybe<number>], R, I, O> => {
+    return self
+      .zip(Schedule.elapsed)
+      .resetWhen(([_, d]) => d >= duration)
+      .map(([out, _]) => out);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule resetWhen
+ * @tsplus pipeable fncts.io.Schedule resetWhen
  */
-export function resetWhen_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return Schedule(self.initial, (now, inp, state) =>
-    self
-      .step(now, inp, state)
-      .flatMap(([state, out, decision]) =>
-        f(out) ? self.step(now, inp, self.initial) : IO.succeedNow([state, out, decision]),
-      ),
-  );
+export function resetWhen<O>(f: (out: O) => boolean, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return Schedule(self.initial, (now, inp, state) =>
+      self
+        .step(now, inp, state)
+        .flatMap(([state, out, decision]) =>
+          f(out) ? self.step(now, inp, self.initial) : IO.succeedNow([state, out, decision]),
+        ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule run
+ * @tsplus pipeable fncts.io.Schedule run
  */
-export function run_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  now: number,
-  input: Iterable<I>,
-  __tsplusTrace?: string,
-): URIO<R, Conc<O>> {
-  const loop = (now: number, xs: List<I>, state: S, acc: Conc<O>): URIO<R, Conc<O>> => {
-    if (xs.isEmpty()) {
-      return IO.succeedNow(acc);
-    } else {
-      return self.step(now, xs.head, state).flatMap(([state, out, decision]) =>
-        decision.match(
-          () => IO.succeed(acc.append(out)),
-          (interval) => loop(interval.start, xs.tail, state, acc.append(out)),
-        ),
-      );
-    }
+export function run<I>(now: number, input: Iterable<I>, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): URIO<R, Conc<O>> => {
+    const loop = (now: number, xs: List<I>, state: S, acc: Conc<O>): URIO<R, Conc<O>> => {
+      if (xs.isEmpty()) {
+        return IO.succeedNow(acc);
+      } else {
+        return self.step(now, xs.head, state).flatMap(([state, out, decision]) =>
+          decision.match(
+            () => IO.succeed(acc.append(out)),
+            (interval) => loop(interval.start, xs.tail, state, acc.append(out)),
+          ),
+        );
+      }
+    };
+    return loop(now, List.from(input), self.initial, Conc.empty());
   };
-  return loop(now, List.from(input), self.initial, Conc.empty());
 }
 
 /**
  * @tsplus static fncts.io.Schedule spaced
  */
-export function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
+export function spaced(duration: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.addDelay(() => duration);
 }
 
@@ -752,58 +766,56 @@ export function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule.WithSta
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule tapInput
+ * @tsplus pipeable fncts.io.Schedule tapInput
  */
-export function tapInput_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I) => URIO<R1, any>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return Schedule(self.initial, (now, inp, state) => f(inp).apSecond(self.step(now, inp, state)));
+export function tapInput<I, R1>(f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return Schedule(self.initial, (now, inp, state) => f(inp).zipRight(self.step(now, inp, state)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule tapOutput
+ * @tsplus pipeable fncts.io.Schedule tapOutput
  */
-export function tapOutput_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => URIO<R1, any>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).tap(([_, out]) => f(out)));
+export function tapOutput<O, R1>(f: (out: O) => URIO<R1, any>, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).tap(([_, out]) => f(out)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule unionWith
+ * @tsplus pipeable fncts.io.Schedule unionWith
  */
-export function unionWith_<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
+export function unionWith<S1, R1, I1, O1>(
   that: Schedule.WithState<S1, R1, I1, O1>,
   f: (int1: Intervals, int2: Intervals) => Intervals,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
-  return Schedule([self.initial, that.initial], (now, inp, state) => {
-    const left  = self.step(now, inp, state[0]);
-    const right = that.step(now, inp, state[1]);
-
-    return left.zipWith(right, ([lstate, l, d1], [rstate, r, d2]) =>
-      d1.match(
-        () =>
-          d2.match(
-            () => [[lstate, rstate], [l, r], Decision.Done],
-            (interval) => [[lstate, rstate], [l, r], Decision.Continue(interval)],
-          ),
-        (linterval) =>
-          d2.match(
-            () => [[lstate, rstate], [l, r], Decision.Continue(linterval)],
-            (rinterval) => {
-              const combined = f(linterval, rinterval);
-              return [[lstate, rstate], [l, r], Decision.Continue(combined)];
-            },
-          ),
-      ),
-    );
-  });
+) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> => {
+    return Schedule([self.initial, that.initial], (now, inp, state) => {
+      const left  = self.step(now, inp, state[0]);
+      const right = that.step(now, inp, state[1]);
+      return left.zipWith(right, ([lstate, l, d1], [rstate, r, d2]) =>
+        d1.match(
+          () =>
+            d2.match(
+              () => [[lstate, rstate], [l, r], Decision.Done],
+              (interval) => [[lstate, rstate], [l, r], Decision.Continue(interval)],
+            ),
+          (linterval) =>
+            d2.match(
+              () => [[lstate, rstate], [l, r], Decision.Continue(linterval)],
+              (rinterval) => {
+                const combined = f(linterval, rinterval);
+                return [[lstate, rstate], [l, r], Decision.Continue(combined)];
+              },
+            ),
+        ),
+      );
+    });
+  };
 }
 
 /**
@@ -820,101 +832,85 @@ export function unfold<A>(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule untilInput
+ * @tsplus pipeable fncts.io.Schedule untilInput
  */
-export function untilInput_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return self.check((inp) => !f(inp));
+export function untilInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return self.check((inp) => !f(inp));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule untilInputIO
+ * @tsplus pipeable fncts.io.Schedule untilInputIO
  */
-export function untilInputIO_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I) => URIO<R1, boolean>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return self.checkIO((inp) => f(inp).map((b) => !b));
+export function untilInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return self.checkIO((inp) => f(inp).map((b) => !b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule untilOutput
+ * @tsplus pipeable fncts.io.Schedule untilOutput
  */
-export function untilOutput_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return self.check((_, out) => !f(out));
+export function untilOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return self.check((_, out) => !f(out));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule untilOutputIO
+ * @tsplus pipeable fncts.io.Schedule untilOutputIO
  */
-export function untilOutputIO_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => URIO<R1, boolean>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return self.checkIO((_, out) => f(out).map((b) => !b));
+export function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return self.checkIO((_, out) => f(out).map((b) => !b));
+  };
 }
 
 /**
  * @tsplus static fncts.io.Schedule upTo
  */
 export function upTo(
-  duration: number,
+  duration: Duration,
   __tsplusTrace?: string,
-): Schedule.WithState<Maybe<number>, never, unknown, number> {
+): Schedule.WithState<Maybe<number>, never, unknown, Duration> {
   return Schedule.elapsed.whileOutput((n) => n < duration);
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule whileInput
+ * @tsplus pipeable fncts.io.Schedule whileInput
  */
-export function whileInput_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return self.check((inp) => f(inp));
+export function whileInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return self.check((inp) => f(inp));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule whileInputIO
+ * @tsplus pipeable fncts.io.Schedule whileInputIO
  */
-export function whileInputIO_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (inp: I) => URIO<R1, boolean>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return self.checkIO((inp) => f(inp));
+export function whileInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string) {
+  return <S, R, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return self.checkIO((inp) => f(inp));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule whileOutput
+ * @tsplus pipeable fncts.io.Schedule whileOutput
  */
-export function whileOutput_<S, R, I, O>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => boolean,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R, I, O> {
-  return self.check((_, out) => f(out));
+export function whileOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> => {
+    return self.check((_, out) => f(out));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule whileOutputIO
+ * @tsplus pipeable fncts.io.Schedule whileOutputIO
  */
-export function whileOutputIO_<S, R, I, O, R1>(
-  self: Schedule.WithState<S, R, I, O>,
-  f: (out: O) => URIO<R1, boolean>,
-  __tsplusTrace?: string,
-): Schedule.WithState<S, R | R1, I, O> {
-  return self.checkIO((_, out) => f(out));
+export function whileOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R | R1, I, O> => {
+    return self.checkIO((_, out) => f(out));
+  };
 }
 
 /**
@@ -939,46 +935,47 @@ export function windowed(
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule zip
+ * @tsplus pipeable fncts.io.Schedule zip
  */
-export function zip_<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
-  that: Schedule.WithState<S1, R1, I1, O1>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
-  return self.intersectWith(that, (lInterval, rInterval) => lInterval.intersect(rInterval));
+export function zip<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> => {
+    return self.intersectWith(that, (lInterval, rInterval) => lInterval.intersect(rInterval));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule zipLeft
+ * @tsplus pipeable fncts.io.Schedule zipLeft
  */
-export function zipLeft_<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
-  that: Schedule.WithState<S1, R1, I1, O1>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O> {
-  return self.zip(that).map(([out]) => out);
+export function zipLeft<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O> => {
+    return self.zip(that).map(([out]) => out);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule zipRight
+ * @tsplus pipeable fncts.io.Schedule zipRight
  */
-export function zipRight_<S, R, I, O, S1, R1, I1, O1>(
-  self: Schedule.WithState<S, R, I, O>,
-  that: Schedule.WithState<S1, R1, I1, O1>,
-  __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1> {
-  return self.zip(that).map(([_, out1]) => out1);
+export function zipRight<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string) {
+  return <S, R, I, O>(
+    self: Schedule.WithState<S, R, I, O>,
+  ): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1> => {
+    return self.zip(that).map(([_, out1]) => out1);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule zipWith
+ * @tsplus pipeable fncts.io.Schedule zipWith
  */
-export function zipWith_<S, R, I, O, S1, R1, I1, O2, O3>(
-  self: Schedule.WithState<S, R, I, O>,
+export function zipWith<O, S1, R1, I1, O2, O3>(
   that: Schedule.WithState<S1, R1, I1, O2>,
   f: (out1: O, out2: O2) => O3,
   __tsplusTrace?: string,
-): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3> {
-  return self.zip(that).map(([out1, out2]) => f(out1, out2));
+) {
+  return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3> => {
+    return self.zip(that).map(([out1, out2]) => f(out1, out2));
+  };
 }