@fncts/io 0.0.11 → 0.0.14

package/_src/Schedule/api.ts

@@ -6,6 +6,7 @@ import { Decision, DecisionTag } from "./Decision.js";
 export function make<State, Env, In, Out>(
   initial: State,
   step: (now: number, inp: In, state: State, __tsplusTrace?: string) => IO<Env, never, readonly [State, Out, Decision]>,
+  __tsplusTrace?: string,
 ): Schedule.WithState<State, Env, In, Out> {
   return new (class extends Schedule<Env, In, Out> {
     readonly _State!: State;
@@ -20,6 +21,7 @@ export function make<State, Env, In, Out>(
 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)));
 }
@@ -30,7 +32,8 @@ export function addDelay_<State, Env, In, Out>(
 export function addDelayIO_<State, Env, In, Out, Env1>(
   self: Schedule.WithState<State, Env, In, Out>,
   f: (out: Out) => URIO<Env1, number>,
-): Schedule.WithState<State, Env & Env1, In, Out> {
+  __tsplusTrace?: string,
+): Schedule.WithState<State, Env | Env1, In, Out> {
   return self.modifyDelayIO((out, duration) => f(out).map((d) => duration + d));
 }
 
@@ -40,7 +43,8 @@ export function addDelayIO_<State, Env, In, Out, Env1>(
 export function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(
   self: Schedule.WithState<State, Env, In, Out>,
   that: Schedule.WithState<State1, Env1, In1, Out1>,
-): Schedule.WithState<readonly [State, State1, boolean], Env & Env1, In & In1, Out | Out1> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1> {
   return self.andThenEither(that).map((out) => out.value);
 }
 
@@ -50,8 +54,9 @@ export function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(
 export function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(
   self: Schedule.WithState<State, Env, In, Out>,
   that: Schedule.WithState<State1, Env1, In1, Out1>,
-): 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>>(
+  __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) {
@@ -79,6 +84,7 @@ export function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(
 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());
 }
@@ -89,6 +95,7 @@ export function as_<State, Env, In, Out, Out2>(
 export function check_<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)));
 }
@@ -99,7 +106,8 @@ export function check_<State, Env, In, Out>(
 export function checkIO_<State, Env, In, Out, Env1>(
   self: Schedule.WithState<State, Env, In, Out>,
   test: (inp: In, out: Out) => URIO<Env1, boolean>,
-): Schedule.WithState<State, Env & Env1, In, Out> {
+  __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(
@@ -117,7 +125,8 @@ export function checkIO_<State, Env, In, Out, Env1>(
 export function compose_<S, R, I, O, S1, R1, O2>(
   self: Schedule.WithState<S, R, I, O>,
   that: Schedule.WithState<S1, R1, O, O2>,
-): Schedule.WithState<readonly [S, S1], R & R1, I, 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(
@@ -140,6 +149,7 @@ export function compose_<S, R, I, O, S1, R1, O2>(
 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)));
 }
@@ -150,6 +160,7 @@ export function contramap_<S, R, I, O, I2>(
 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));
 }
@@ -160,14 +171,18 @@ export function contramapEnvironment_<S, R, I, O, R1>(
 export function contramapIO_<S, R, I, O, R1, I2>(
   self: Schedule.WithState<S, R, I, O>,
   f: (inp: I2) => URIO<R1, I>,
-): Schedule.WithState<S, R & R1, I2, O> {
+  __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)));
 }
 
 /**
  * @tsplus static fncts.io.ScheduleOps delayed
  */
-export function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>): Schedule.WithState<S, R, I, number> {
+export function delayed<S, R, I>(
+  schedule: Schedule.WithState<S, R, I, number>,
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R, I, number> {
   return schedule.addDelay((x) => x);
 }
 
@@ -177,6 +192,7 @@ export function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>):
 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)));
 }
@@ -187,20 +203,24 @@ export function delayedSelf_<S, R, I, O>(
 export function delayedIO_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (delay: number) => URIO<R1, number>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R | R1, I, O> {
   return self.modifyDelayIO((_, delay) => f(delay));
 }
 
 /**
  * @tsplus getter fncts.io.Schedule delays
  */
-export function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, number> {
+export function delays<S, R, I, O>(
+  self: Schedule.WithState<S, R, I, O>,
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R, I, number> {
   return Schedule(self.initial, (now, inp, state) =>
     self.step(now, inp, state).flatMap(([state, _, decision]) =>
       decision.match(
         () => IO.succeedNow([state, 0, Decision.Done]),
         (interval) => {
-          const delay = interval.startMilliseconds - now;
+          const delay = interval.start - now;
           return IO.succeedNow([state, delay, Decision.Continue(interval)]);
         },
       ),
@@ -215,6 +235,7 @@ 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);
 }
@@ -226,19 +247,23 @@ export function dimapIO_<S, R, I, O, R1, I2, R2, O2>(
   self: Schedule.WithState<S, R, I, O>,
   f: (inp2: I2) => URIO<R1, I>,
   g: (out: O) => URIO<R2, O2>,
-): Schedule.WithState<S, R & R1 & R2, I2, O2> {
+  __tsplusTrace?: string,
+): 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): Schedule.WithState<boolean, unknown, unknown, number> {
-  return Schedule<boolean, unknown, unknown, number>(true, (now, _, state) =>
+export function duration(
+  duration: number,
+  __tsplusTrace?: string,
+): Schedule.WithState<boolean, never, unknown, number> {
+  return Schedule<boolean, never, unknown, number>(true, (now, _, state) =>
     IO.succeed(() => {
       if (state) {
         const interval = Interval.after(now + duration);
-        return [false, duration, Decision.Continue(interval)];
+        return [false, duration, Decision.continueWith(interval)];
       } else {
         return [false, 0, Decision.Done];
       }
@@ -246,21 +271,43 @@ export function duration(duration: number): Schedule.WithState<boolean, unknown,
   );
 }
 
+/**
+ * @tsplus fluent fncts.io.Schedule either
+ * @tsplus 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);
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule eitherWith
+ */
+export function eitherWith<S, R, I, O, S1, R1, I1, O1, O2>(
+  self: Schedule.WithState<S, R, I, O>,
+  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);
+}
+
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  */
-export const elapsed: Schedule.WithState<Maybe<number>, unknown, unknown, number> = Schedule(
-  Nothing(),
-  (now, _, state) =>
-    IO.succeed(
-      state.match(
-        () => [Just(now), 0, Decision.Continue(Interval(now, Number.MAX_SAFE_INTEGER))],
-        (start) => {
-          const duration = now - start;
-          return [Just(start), duration, Decision.Continue(Interval(now, Number.MAX_SAFE_INTEGER))];
-        },
-      ),
+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))];
+      },
     ),
+  ),
 );
 
 /**
@@ -269,6 +316,7 @@ export const elapsed: Schedule.WithState<Maybe<number>, unknown, unknown, number
 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]) =>
@@ -283,7 +331,11 @@ export function ensuring_<S, R, I, O>(
 /**
  * @tsplus static fncts.io.ScheduleOps exponential
  */
-export function exponential(base: number, factor = 2): Schedule.WithState<number, unknown, unknown, number> {
+export function exponential(
+  base: number,
+  factor = 2,
+  __tsplusTrace?: string,
+): Schedule.WithState<number, never, unknown, number> {
   return Schedule.delayed(Schedule.forever.map((i) => base * Math.pow(factor, i)));
 }
 
@@ -303,20 +355,21 @@ export function exponential(base: number, factor = 2): Schedule.WithState<number
  */
 export function fixed(
   interval: number,
-): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], unknown, unknown, number> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number> {
   return Schedule([Nothing(), 0], (now, inp, [ms, n]) =>
     IO.succeed(
       ms.match(
         () => {
           const nextRun = now + interval;
-          return [[Just([now, nextRun]), n + 1], n, Decision.Continue(Interval.after(nextRun))];
+          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 nextRun       = runningBehind ? now : now + sleepTime;
-          return [[Just([startMillis, nextRun]), n + 1], n, Decision.Continue(Interval.after(nextRun))];
+          return [[Just([startMillis, nextRun]), n + 1], n, Decision.continueWith(Interval.after(nextRun))];
         },
       ),
     ),
@@ -330,6 +383,7 @@ 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)));
 }
@@ -341,7 +395,8 @@ 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>,
-): Schedule.WithState<readonly [S, Z], R & R1, I, 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(
@@ -355,7 +410,10 @@ export function foldIO_<S, R, I, O, Z, R1>(
 /**
  * @tsplus getter fncts.io.Schedule forever
  */
-export function foreverSelf<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O> {
+export function foreverSelf<S, R, I, O>(
+  self: Schedule.WithState<S, R, I, O>,
+  __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(
@@ -374,8 +432,8 @@ export const forever = Schedule.unfold(0, (n) => n + 1);
 /**
  * @tsplus static fncts.io.ScheduleOps identity
  */
-export function identity<A>(): Schedule.WithState<void, unknown, A, A> {
-  return Schedule(undefined, (now, inp, state) => IO.succeed([state, inp, Decision.Continue(Interval.after(now))]));
+export function identity<A>(__tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
+  return Schedule(undefined, (now, inp, state) => IO.succeed([state, inp, Decision.continueWith(Interval.after(now))]));
 }
 
 function intersectWithLoop<S, R, I, O, S1, R1, I1, O1>(
@@ -384,24 +442,25 @@ function intersectWithLoop<S, R, I, O, S1, R1, I1, O1>(
   inp: I & I1,
   lState: S,
   out: O,
-  lInterval: Interval,
+  lInterval: Intervals,
   rState: S1,
   out2: O1,
-  rInterval: Interval,
-  f: (lInterval: Interval, rInterval: Interval) => Interval,
-): IO<R & R1, never, readonly [readonly [S, S1], readonly [O, O1], Decision]> {
+  rInterval: Intervals,
+  f: (lInterval: Intervals, rInterval: Intervals) => Intervals,
+  __tsplusTrace?: string,
+): IO<R | R1, never, readonly [readonly [S, S1], readonly [O, O1], Decision]> {
   const combined = f(lInterval, rInterval);
   if (combined.isNonEmpty) {
     return IO.succeedNow([[lState, rState], [out, out2], Decision.Continue(combined)]);
   } else if (lInterval < rInterval) {
-    return self.step(lInterval.endMilliseconds, inp, lState).flatMap(([lState, out, decision]) =>
+    return self.step(lInterval.end, inp, lState).flatMap(([lState, out, decision]) =>
       decision.match(
         () => IO.succeedNow([[lState, rState], [out, out2], Decision.Done]),
         (lInterval) => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f),
       ),
     );
   } else {
-    return that.step(rInterval.endMilliseconds, inp, rState).flatMap(([rState, out2, decision]) =>
+    return that.step(rInterval.end, inp, rState).flatMap(([rState, out2, decision]) =>
       decision.match(
         () => IO.succeedNow([[lState, rState], [out, out2], Decision.Done]),
         (rInterval) => intersectWithLoop(self, that, inp, lState, out, lInterval, rState, out2, rInterval, f),
@@ -416,8 +475,9 @@ function intersectWithLoop<S, R, I, O, S1, R1, I1, O1>(
 export function intersectWith_<S, R, I, O, S1, R1, I1, O1>(
   self: Schedule.WithState<S, R, I, O>,
   that: Schedule.WithState<S1, R1, I1, O1>,
-  f: (int1: Interval, int2: Interval) => Interval,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, 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]);
@@ -435,7 +495,7 @@ export function intersectWith_<S, R, I, O, S1, R1, I1, O1>(
 /**
  * @tsplus static fncts.io.Schedule linear
  */
-export function linear(base: number): Schedule.WithState<number, unknown, unknown, number> {
+export function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.delayed(Schedule.forever.map((i) => base * (i + 1)));
 }
 
@@ -445,6 +505,7 @@ export function linear(base: number): Schedule.WithState<number, unknown, unknow
 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)));
 }
@@ -455,7 +516,8 @@ export function map_<State, Env, In, Out, Out1>(
 export function mapIO_<State, Env, In, Out, Env1, Out1>(
   self: Schedule.WithState<State, Env, In, Out>,
   f: (out: Out) => URIO<Env1, Out1>,
-): Schedule.WithState<State, Env & Env1, In, 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])),
   );
@@ -467,21 +529,22 @@ export function mapIO_<State, Env, In, Out, Env1, Out1>(
 export function modifyDelayIO_<State, Env, In, Out, Env1>(
   self: Schedule.WithState<State, Env, In, Out>,
   f: (out: Out, duration: number) => URIO<Env1, number>,
-): Schedule.WithState<State, Env & Env1, In, Out> {
+  __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.startMilliseconds).size;
+          const delay = Interval(now, interval.start).size;
 
           return f(out, delay).map((duration) => {
-            const oldStart    = interval.startMilliseconds;
+            const oldStart    = interval.start;
             const newStart    = now + duration;
             const delta       = newStart - oldStart;
-            const newEnd      = interval.endMilliseconds + delta;
+            const newEnd      = interval.end + delta;
             const newInterval = Interval(newStart, newEnd);
-            return [state, out, Decision.Continue(newInterval)];
+            return [state, out, Decision.continueWith(newInterval)];
           });
         },
       ),
@@ -495,7 +558,8 @@ export function modifyDelayIO_<State, Env, In, Out, Env1>(
 export function onDecision_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (state: S, out: O, decision: Decision) => URIO<R1, any>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __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])),
   );
@@ -507,7 +571,8 @@ export function onDecision_<S, R, I, O, R1>(
 export function provideEnvironment_<S, R, I, O>(
   self: Schedule.WithState<S, R, I, O>,
   env: Environment<R>,
-): Schedule.WithState<S, unknown, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, never, I, O> {
   return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).provideEnvironment(env));
 }
 
@@ -517,6 +582,7 @@ export function provideEnvironment_<S, R, I, O>(
 export function reconsider_<S, R, I, O, O2>(
   self: Schedule.WithState<S, R, I, O>,
   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)));
 }
@@ -527,7 +593,8 @@ export function reconsider_<S, R, I, O, O2>(
 export function reconsiderIO_<S, R, I, O, R1, O1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>,
-): Schedule.WithState<S, R & R1, I, O1> {
+  __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(
@@ -542,7 +609,7 @@ export function reconsiderIO_<S, R, I, O, R1, O1>(
           f(state, out, decision).map((r) =>
             r.match(
               (out1) => [state, out1, Decision.Done],
-              ([out1, interval]) => [state, out1, Decision.Continue(interval)],
+              ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
             ),
           ),
       ),
@@ -553,49 +620,55 @@ export function reconsiderIO_<S, R, I, O, R1, O1>(
 /**
  * @tsplus static fncts.io.Schedule recurs
  */
-export function recurs(n: number): Schedule.WithState<number, unknown, unknown, number> {
+export function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.whileOutput((_) => _ < n);
 }
 
 /**
  * @tsplus static fncts.io.Schedule recurWhile
  */
-export function recurWhile<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A> {
+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
  */
-export function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A> {
+export function recurWhileIO<R, A>(
+  f: (a: A) => URIO<R, boolean>,
+  __tsplusTrace?: string,
+): Schedule.WithState<void, R, A, A> {
   return identity<A>().whileInputIO(f);
 }
 
 /**
  * @tsplus static fncts.io.Schedule recurWhileEquals
  */
-export function recurWhileEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A> {
+export function recurWhileEquals<A>(value: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
   return identity<A>().whileInput((a) => Equatable.strictEquals(a, value()));
 }
 
 /**
  * @tsplus static fncts.io.Schedule recurUntil
  */
-export function recurUntil<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A> {
+export function recurUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
   return identity<A>().untilInput(f);
 }
 
 /**
  * @tsplus static fncts.io.Schedule recurUntilIO
  */
-export function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A> {
+export function recurUntilIO<R, A>(
+  f: (a: A) => URIO<R, boolean>,
+  __tsplusTrace?: string,
+): Schedule.WithState<void, R, A, A> {
   return identity<A>().untilInputIO(f);
 }
 
 /**
  * @tsplus static fncts.io.Schedule recurUntilEquals
  */
-export function recurUntilEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A> {
+export function recurUntilEquals<A>(value: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<void, never, A, A> {
   return identity<A>().untilInput((a) => Equatable.strictEquals(a, value()));
 }
 
@@ -604,6 +677,7 @@ export function recurUntilEquals<A>(value: Lazy<A>): Schedule.WithState<void, un
  */
 export function repetitions<S, R, I, O>(
   self: Schedule.WithState<S, R, I, O>,
+  __tsplusTrace?: string,
 ): Schedule.WithState<readonly [S, number], R, I, number> {
   return self.fold(0, (n, _) => n + 1);
 }
@@ -614,6 +688,7 @@ export function repetitions<S, R, I, O>(
 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)
@@ -627,6 +702,7 @@ export function resetAfter_<S, R, I, O>(
 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
@@ -644,6 +720,7 @@ 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()) {
@@ -652,7 +729,7 @@ export function run_<S, R, I, O>(
       return self.step(now, xs.head, state).flatMap(([state, out, decision]) =>
         decision.match(
           () => IO.succeed(acc.append(out)),
-          (interval) => loop(interval.startMilliseconds, xs.tail, state, acc.append(out)),
+          (interval) => loop(interval.start, xs.tail, state, acc.append(out)),
         ),
       );
     }
@@ -663,14 +740,14 @@ export function run_<S, R, I, O>(
 /**
  * @tsplus static fncts.io.Schedule spaced
  */
-export function spaced(duration: number): Schedule.WithState<number, unknown, unknown, number> {
+export function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number> {
   return Schedule.forever.addDelay(() => duration);
 }
 
 /**
  * @tsplus static fncts.io.Schedule succeed
  */
-export function succeed<A>(a: Lazy<A>): Schedule.WithState<number, unknown, unknown, A> {
+export function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, A> {
   return Schedule.forever.as(a);
 }
 
@@ -680,7 +757,8 @@ export function succeed<A>(a: Lazy<A>): Schedule.WithState<number, unknown, unkn
 export function tapInput_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (inp: I) => URIO<R1, any>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R | R1, I, O> {
   return Schedule(self.initial, (now, inp, state) => f(inp).apSecond(self.step(now, inp, state)));
 }
 
@@ -690,7 +768,8 @@ export function tapInput_<S, R, I, O, R1>(
 export function tapOutput_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (out: O) => URIO<R1, any>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __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)));
 }
 
@@ -700,8 +779,9 @@ export function tapOutput_<S, R, I, O, R1>(
 export function unionWith_<S, R, I, O, S1, R1, I1, O1>(
   self: Schedule.WithState<S, R, I, O>,
   that: Schedule.WithState<S1, R1, I1, O1>,
-  f: (int1: Interval, int2: Interval) => Interval,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, 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]);
@@ -729,9 +809,13 @@ export function unionWith_<S, R, I, O, S1, R1, I1, O1>(
 /**
  * @tsplus static fncts.io.ScheduleOps unfold
  */
-export function unfold<A>(a: Lazy<A>, f: (a: A) => A): Schedule.WithState<A, unknown, unknown, A> {
-  return Schedule<A, unknown, unknown, A>(a(), (now, inp, state) =>
-    IO.succeed([f(state), state, Decision.Continue(Interval(now, Number.MAX_SAFE_INTEGER))]),
+export function unfold<A>(
+  a: Lazy<A>,
+  f: (a: A) => A,
+  __tsplusTrace?: string,
+): Schedule.WithState<A, never, unknown, A> {
+  return Schedule<A, never, unknown, A>(a(), (now, inp, state) =>
+    IO.succeed([f(state), state, Decision.continueWith(Interval(now, Number.MAX_SAFE_INTEGER))]),
   );
 }
 
@@ -741,6 +825,7 @@ export function unfold<A>(a: Lazy<A>, f: (a: A) => A): Schedule.WithState<A, unk
 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));
 }
@@ -751,7 +836,8 @@ export function untilInput_<S, R, I, O>(
 export function untilInputIO_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (inp: I) => URIO<R1, boolean>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((inp) => f(inp).map((b) => !b));
 }
 
@@ -761,6 +847,7 @@ export function untilInputIO_<S, R, I, O, R1>(
 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));
 }
@@ -771,14 +858,18 @@ export function untilOutput_<S, R, I, O>(
 export function untilOutputIO_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (out: O) => URIO<R1, boolean>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): 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): Schedule.WithState<Maybe<number>, unknown, unknown, number> {
+export function upTo(
+  duration: number,
+  __tsplusTrace?: string,
+): Schedule.WithState<Maybe<number>, never, unknown, number> {
   return Schedule.elapsed.whileOutput((n) => n < duration);
 }
 
@@ -788,6 +879,7 @@ export function upTo(duration: number): Schedule.WithState<Maybe<number>, unknow
 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));
 }
@@ -798,7 +890,8 @@ export function whileInput_<S, R, I, O>(
 export function whileInputIO_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (inp: I) => URIO<R1, boolean>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((inp) => f(inp));
 }
 
@@ -808,6 +901,7 @@ export function whileInputIO_<S, R, I, O, R1>(
 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));
 }
@@ -818,7 +912,8 @@ export function whileOutput_<S, R, I, O>(
 export function whileOutputIO_<S, R, I, O, R1>(
   self: Schedule.WithState<S, R, I, O>,
   f: (out: O) => URIO<R1, boolean>,
-): Schedule.WithState<S, R & R1, I, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((_, out) => f(out));
 }
 
@@ -827,15 +922,16 @@ export function whileOutputIO_<S, R, I, O, R1>(
  */
 export function windowed(
   interval: number,
-): Schedule.WithState<readonly [Maybe<number>, number], unknown, unknown, number> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [Maybe<number>, number], never, unknown, number> {
   return Schedule([Nothing(), 0], (now, inp, [m, n]) =>
     IO.succeed(() =>
       m.match(
-        () => [[Just(now), n + 1], n, Decision.Continue(Interval.after(now + interval))],
+        () => [[Just(now), n + 1], n, Decision.continueWith(Interval.after(now + interval))],
         (startMillis) => [
           [Just(startMillis), n + 1],
           n,
-          Decision.Continue(Interval.after(now + (interval - ((now - startMillis) % interval)))),
+          Decision.continueWith(Interval.after(now + (interval - ((now - startMillis) % interval)))),
         ],
       ),
     ),
@@ -848,7 +944,8 @@ export function windowed(
 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>,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
   return self.intersectWith(that, (lInterval, rInterval) => lInterval.intersect(rInterval));
 }
 
@@ -858,7 +955,8 @@ export function zip_<S, R, I, O, S1, R1, I1, O1>(
 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>,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O> {
   return self.zip(that).map(([out]) => out);
 }
 
@@ -868,7 +966,8 @@ export function zipLeft_<S, R, I, O, S1, R1, I1, O1>(
 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>,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O1> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1> {
   return self.zip(that).map(([_, out1]) => out1);
 }
 
@@ -879,6 +978,7 @@ export function zipWith_<S, R, I, O, S1, R1, I1, O2, O3>(
   self: Schedule.WithState<S, R, I, O>,
   that: Schedule.WithState<S1, R1, I1, O2>,
   f: (out1: O, out2: O2) => O3,
-): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O3> {
+  __tsplusTrace?: string,
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3> {
   return self.zip(that).map(([out1, out2]) => f(out1, out2));
 }