@fncts/io 0.0.11 → 0.0.14

package/_src/STM/driver.ts

@@ -14,7 +14,7 @@ type Cont =
 
 export class STMDriver<R, E, A> {
   private contStack: Stack<Cont>;
-  private envStack: Stack<unknown>;
+  private envStack: Stack<Environment<unknown>>;
 
   constructor(readonly self: STM<R, E, A>, readonly journal: Journal, readonly fiberId: FiberId, r0: Environment<R>) {
     this.contStack = Stack();
@@ -68,7 +68,7 @@ export class STMDriver<R, E, A> {
           break;
         }
         case STMTag.ContramapEnvironment: {
-          this.envStack.push(k.f(this.envStack.peek()));
+          this.envStack.push(k.f(this.envStack.peek() ?? Environment()));
           curr = k.stm.ensuring(
             STM.succeed(() => {
               this.envStack.pop();
@@ -93,7 +93,7 @@ export class STMDriver<R, E, A> {
         }
         case STMTag.Effect: {
           try {
-            const a = k.f(this.journal, this.fiberId, this.envStack.peek());
+            const a = k.f(this.journal, this.fiberId, this.envStack.peek() ?? Environment());
             if (!this.contStack.hasNext) {
               exit = TExit.succeed(a);
             } else {

package/_src/STM/internal/Journal.ts

@@ -1,6 +1,7 @@
 import type { Entry } from "./Entry.js";
 import type { TryCommit } from "./TryCommit.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Scheduler } from "@fncts/io/internal/Scheduler";
 import type { Atomic } from "@fncts/io/TRef";
 import type { TxnId } from "@fncts/io/TxnId";
 
@@ -127,10 +128,10 @@ export function execTodos(todos: Map<TxnId, Todo>) {
  *
  * @tsplus fluent fncts.io.Journal completeTodos
  */
-export function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>): Done<E, A> {
+export function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>, scheduler: Scheduler): Done<E, A> {
   const todos = collectTodos(journal);
   if (todos.size > 0) {
-    defaultScheduler(() => execTodos(todos));
+    scheduler.scheduleTask(() => execTodos(todos));
   }
   return new Done(exit);
 }
@@ -180,7 +181,12 @@ export function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal):
   return untracked;
 }
 
-export function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>): TryCommit<E, A> {
+export function tryCommitSync<R, E, A>(
+  fiberId: FiberId,
+  stm: STM<R, E, A>,
+  r: Environment<R>,
+  scheduler: Scheduler,
+): TryCommit<E, A> {
   const journal: Journal = new Map();
   const value            = new STMDriver(stm, journal, fiberId, r).run();
   const analysis         = journal.analyze();
@@ -194,16 +200,16 @@ export function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: E
       return new Suspend(journal);
     }
     case TExitTag.Succeed: {
-      return journal.completeTodos(Exit.succeed(value.value));
+      return journal.completeTodos(Exit.succeed(value.value), scheduler);
     }
     case TExitTag.Fail: {
-      return journal.completeTodos(Exit.fail(value.value));
+      return journal.completeTodos(Exit.fail(value.value), scheduler);
     }
     case TExitTag.Halt: {
-      return journal.completeTodos(Exit.halt(value.value));
+      return journal.completeTodos(Exit.halt(value.value), scheduler);
     }
     case TExitTag.Interrupt: {
-      return journal.completeTodos(Exit.interrupt(value.fiberId));
+      return journal.completeTodos(Exit.interrupt(value.fiberId), scheduler);
     }
   }
 }
@@ -213,6 +219,7 @@ function tryCommit<R, E, A>(
   stm: STM<R, E, A>,
   state: AtomicReference<CommitState<E, A>>,
   r: Environment<R>,
+  scheduler: Scheduler,
 ): TryCommit<E, A> {
   const journal: Journal = new Map();
   const value            = new STMDriver(stm, journal, fiberId, r).run();
@@ -228,16 +235,16 @@ function tryCommit<R, E, A>(
       return new Suspend(journal);
     }
     case TExitTag.Succeed: {
-      return journal.completeTodos(Exit.succeed(value.value));
+      return journal.completeTodos(Exit.succeed(value.value), scheduler);
     }
     case TExitTag.Fail: {
-      return journal.completeTodos(Exit.fail(value.value));
+      return journal.completeTodos(Exit.fail(value.value), scheduler);
     }
     case TExitTag.Halt: {
-      return journal.completeTodos(Exit.halt(value.value));
+      return journal.completeTodos(Exit.halt(value.value), scheduler);
     }
     case TExitTag.Interrupt: {
-      return journal.completeTodos(Exit.interrupt(value.fiberId));
+      return journal.completeTodos(Exit.interrupt(value.fiberId), scheduler);
     }
   }
 }
@@ -255,12 +262,13 @@ function suspendTryCommit<R, E, A>(
   k: (_: IO<R, E, A>) => unknown,
   accum: Journal,
   journal: Journal,
+  scheduler: Scheduler,
 ): void {
   // eslint-disable-next-line no-constant-condition
   while (1) {
-    journal.addTodo(txnId, () => tryCommitAsync(undefined, fiberId, stm, txnId, state, r)(k));
+    journal.addTodo(txnId, () => tryCommitAsync(undefined, fiberId, stm, txnId, state, r, scheduler)(k));
     if (isInvalid(journal)) {
-      const result = tryCommit(fiberId, stm, state, r);
+      const result = tryCommit(fiberId, stm, state, r, scheduler);
       switch (result._tag) {
         case "Done": {
           completeTryCommit(result.exit, k);
@@ -293,20 +301,21 @@ export function tryCommitAsync<R, E, A>(
   txnId: TxnId,
   state: AtomicReference<CommitState<E, A>>,
   r: Environment<R>,
+  scheduler: Scheduler,
 ): (k: (_: IO<R, E, A>) => unknown) => void {
   return (k) => {
     if (state.get.isRunning) {
       if (journal != null) {
-        suspendTryCommit(fiberId, stm, txnId, state, r, k, journal, journal);
+        suspendTryCommit(fiberId, stm, txnId, state, r, k, journal, journal, scheduler);
       } else {
-        const result = tryCommitSync(fiberId, stm, r);
+        const result = tryCommitSync(fiberId, stm, r, scheduler);
         switch (result._tag) {
           case "Done": {
             completeTryCommit(result.exit, k);
             break;
           }
           case "Suspend": {
-            suspendTryCommit(fiberId, stm, txnId, state, r, k, result.journal, result.journal);
+            suspendTryCommit(fiberId, stm, txnId, state, r, k, result.journal, result.journal, scheduler);
             break;
           }
         }

package/_src/Schedule/Decision.ts

@@ -5,7 +5,7 @@ export const enum DecisionTag {
 
 export class Continue {
   readonly _tag = DecisionTag.Continue;
-  constructor(readonly interval: Interval) {}
+  constructor(readonly interval: Intervals) {}
 }
 
 export class Done {
@@ -32,14 +32,21 @@ export const done: Decision = new Done();
 /**
  * @tsplus static fncts.io.Schedule.DecisionOps Continue
  */
-export function continue_(interval: Interval): Decision {
+export function continue_(interval: Intervals): Decision {
   return new Continue(interval);
 }
 
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps continueWith
+ */
+export function continueWith(interval: Interval): Decision {
+  return new Continue(Intervals(List(interval)));
+}
+
 /**
  * @tsplus fluent fncts.io.Schedule.Decision match
  */
-export function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Interval) => B): A | B {
+export function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Intervals) => B): A | B {
   switch (self._tag) {
     case DecisionTag.Continue:
       return onContinue(self.interval);

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),
           ),
         );