@fncts/io 0.0.10 → 0.0.13

package/_src/Schedule/Driver.ts

@@ -5,7 +5,7 @@
 export class Driver<State, Env, In, Out> {
   constructor(
     readonly next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>,
-    readonly last: IO<unknown, NoSuchElementError, Out>,
+    readonly last: IO<never, NoSuchElementError, Out>,
     readonly reset: UIO<void>,
     readonly state: UIO<State>,
   ) {}
@@ -16,7 +16,7 @@ export class Driver<State, Env, In, Out> {
  */
 export function makeDriver<State, Env, In, Out>(
   next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>,
-  last: IO<unknown, NoSuchElementError, Out>,
+  last: IO<never, NoSuchElementError, Out>,
   reset: UIO<void>,
   state: UIO<State>,
 ): Driver<State, Env, In, Out> {

package/_src/Schedule/api/driver.ts

@@ -9,17 +9,17 @@ export function driver<State, Env, In, Out>(
 ): UIO<Schedule.Driver<State, Env, In, Out>> {
   return Ref.make<readonly [Maybe<Out>, State]>([Nothing(), schedule.initial]).map((ref) => {
     const next = (inp: In, __tsplusTrace?: string) =>
-      IO.gen(function* (_) {
-        const state                   = yield* _(ref.get.map(([_, s]) => s));
-        const now                     = yield* _(Clock.currentTime);
-        const [state1, out, decision] = yield* _(schedule.step(now, inp, state));
-        return yield* _(
+      Do((_) => {
+        const state                   = _(ref.get.map(([_, s]) => s));
+        const now                     = _(Clock.currentTime);
+        const [state1, out, decision] = _(schedule.step(now, inp, state));
+        return _(
           decision.match(
             () => ref.set([Just(out), state1]).apSecond(IO.failNow(Nothing() as Nothing)),
             (interval) =>
               ref
                 .set([Just(out), state1])
-                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.startMilliseconds)))
+                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.start)))
                 .as(out),
           ),
         );

package/_src/Schedule/api.ts

@@ -30,7 +30,7 @@ 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> {
+): Schedule.WithState<State, Env | Env1, In, Out> {
   return self.modifyDelayIO((out, duration) => f(out).map((d) => duration + d));
 }
 
@@ -40,7 +40,7 @@ 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> {
+): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1> {
   return self.andThenEither(that).map((out) => out.value);
 }
 
@@ -50,8 +50,8 @@ 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>>(
+): 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) {
@@ -99,7 +99,7 @@ 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> {
+): 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 +117,7 @@ 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> {
+): 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(
@@ -160,7 +160,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I2, O> {
   return Schedule(self.initial, (now, inp2, state) => f(inp2).flatMap((inp) => self.step(now, inp, state)));
 }
 
@@ -187,7 +187,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I, O> {
   return self.modifyDelayIO((_, delay) => f(delay));
 }
 
@@ -200,7 +200,7 @@ export function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedu
       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)]);
         },
       ),
@@ -226,19 +226,19 @@ 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> {
+): 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): 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 +246,41 @@ 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>,
+): 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,
+): 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))];
+      },
     ),
+  ),
 );
 
 /**
@@ -283,7 +303,7 @@ 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): Schedule.WithState<number, never, unknown, number> {
   return Schedule.delayed(Schedule.forever.map((i) => base * Math.pow(factor, i)));
 }
 
@@ -303,20 +323,20 @@ 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> {
+): 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))];
         },
       ),
     ),
@@ -341,7 +361,7 @@ 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> {
+): 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(
@@ -374,8 +394,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>(): 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 +404,24 @@ 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,
+): 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 +436,8 @@ 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,
+): 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 +455,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): Schedule.WithState<number, never, unknown, number> {
   return Schedule.delayed(Schedule.forever.map((i) => base * (i + 1)));
 }
 
@@ -455,7 +475,7 @@ 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> {
+): 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 +487,21 @@ 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> {
+): 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 +515,7 @@ 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> {
+): 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 +527,7 @@ 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> {
+): Schedule.WithState<S, never, I, O> {
   return Schedule(self.initial, (now, inp, state) => self.step(now, inp, state).provideEnvironment(env));
 }
 
@@ -527,7 +547,7 @@ 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> {
+): 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 +562,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,14 +573,14 @@ 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): 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): Schedule.WithState<void, never, A, A> {
   return identity<A>().whileInput(f);
 }
 
@@ -574,14 +594,14 @@ export function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.With
 /**
  * @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>): 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): Schedule.WithState<void, never, A, A> {
   return identity<A>().untilInput(f);
 }
 
@@ -595,7 +615,7 @@ export function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.With
 /**
  * @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>): Schedule.WithState<void, never, A, A> {
   return identity<A>().untilInput((a) => Equatable.strictEquals(a, value()));
 }
 
@@ -652,7 +672,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 +683,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): 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>): Schedule.WithState<number, never, unknown, A> {
   return Schedule.forever.as(a);
 }
 
@@ -680,7 +700,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I, O> {
   return Schedule(self.initial, (now, inp, state) => f(inp).apSecond(self.step(now, inp, state)));
 }
 
@@ -690,7 +710,7 @@ 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> {
+): 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 +720,8 @@ 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,
+): 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 +749,9 @@ 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): 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))]),
   );
 }
 
@@ -751,7 +771,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((inp) => f(inp).map((b) => !b));
 }
 
@@ -771,14 +791,14 @@ 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> {
+): 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): Schedule.WithState<Maybe<number>, never, unknown, number> {
   return Schedule.elapsed.whileOutput((n) => n < duration);
 }
 
@@ -798,7 +818,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((inp) => f(inp));
 }
 
@@ -818,7 +838,7 @@ 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> {
+): Schedule.WithState<S, R | R1, I, O> {
   return self.checkIO((_, out) => f(out));
 }
 
@@ -827,15 +847,15 @@ export function whileOutputIO_<S, R, I, O, R1>(
  */
 export function windowed(
   interval: number,
-): Schedule.WithState<readonly [Maybe<number>, number], unknown, unknown, number> {
+): 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 +868,7 @@ 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]> {
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]> {
   return self.intersectWith(that, (lInterval, rInterval) => lInterval.intersect(rInterval));
 }
 
@@ -858,7 +878,7 @@ 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> {
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O> {
   return self.zip(that).map(([out]) => out);
 }
 
@@ -868,7 +888,7 @@ 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> {
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1> {
   return self.zip(that).map(([_, out1]) => out1);
 }
 
@@ -879,6 +899,6 @@ 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> {
+): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3> {
   return self.zip(that).map(([out1, out2]) => f(out1, out2));
 }

package/_src/Schedule/definition.ts

@@ -32,7 +32,7 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export abstract class Schedule<Env, In, Out> {
-  readonly _Env!: (_: Env) => void;
+  readonly _Env!: () => Env;
   readonly _In!: (_: In) => void;
   readonly _Out!: () => Out;
   readonly _State!: unknown;

package/_src/Scope/Finalizer/definition.ts

@@ -1,5 +1,5 @@
 interface FinalizerN extends HKT {
-  readonly [HKT.T]: Finalizer;
+  readonly type: Finalizer;
 }
 
 /**
@@ -10,7 +10,7 @@ export interface Finalizer
     {
       readonly Finalizer: unique symbol;
     },
-    (exit: Exit<any, any>) => IO<unknown, never, any>
+    (exit: Exit<any, any>) => IO<never, never, any>
   > {}
 
 /**

package/_src/Scope/ReleaseMap/api.ts

@@ -23,7 +23,7 @@ export function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Ma
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap release
  */
-export function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any> {
+export function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<never, never, any> {
   return ReleaseMap.reverseGet(releaseMap).modify((s) => {
     switch (s._tag) {
       case "Exited": {

package/_src/Scope/ReleaseMap/definition.ts

@@ -15,7 +15,7 @@ export class Running {
 export type State = Exited | Running;
 
 interface ReleaseMapN extends HKT {
-  readonly [HKT.T]: ReleaseMap;
+  readonly type: ReleaseMap;
 }
 
 /**