@fncts/io 0.0.1

package/_src/STM/internal/Journal.ts

@@ -0,0 +1,341 @@
+import type { Entry } from "./Entry.js";
+import type { TryCommit } from "./TryCommit.js";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Atomic } from "@fncts/io/TRef";
+import type { TxnId } from "@fncts/io/TxnId";
+
+import { defaultScheduler } from "@fncts/io/internal/Scheduler";
+import { TExitTag } from "@fncts/io/TExit";
+
+import { STMDriver } from "../driver.js";
+import { CommitState } from "./CommitState.js";
+import { Done, Suspend } from "./TryCommit.js";
+
+/**
+ * @tsplus type fncts.io.Journal
+ */
+export type Journal = Map<Atomic<any>, Entry>;
+
+/**
+ * @tsplus type fncts.io.JournalOps
+ */
+export interface JournalOps {}
+
+export const Journal: JournalOps = {};
+
+export type Todo = () => unknown;
+
+/**
+ * Creates a function that can reset the journal.
+ *
+ * @tsplus fluent fncts.io.Journal prepareReset
+ */
+export function prepareResetJournal(journal: Journal): () => unknown {
+  const saved: Journal = new Map();
+  for (const entry of journal) {
+    saved.set(
+      entry[0],
+      entry[1].use((_) => _.copy()),
+    );
+  }
+  return () => {
+    journal.clear();
+    for (const entry of saved) {
+      journal.set(entry[0], entry[1]);
+    }
+  };
+}
+
+/**
+ * Commits the journal.
+ *
+ * @tsplus fluent fncts.io.Journal commit
+ */
+export function commitJournal(journal: Journal) {
+  for (const entry of journal.values()) {
+    entry.use((entry) => entry.commit());
+  }
+}
+
+type Invalid = -1;
+const Invalid = -1;
+type ReadOnly = 0;
+const ReadOnly = 0;
+type ReadWrite = 1;
+const ReadWrite = 1;
+
+type JournalAnalysis = Invalid | ReadOnly | ReadWrite;
+
+/**
+ * Analyzes the journal, determining whether it is valid and whether it is
+ * read only in a single pass. Note that information on whether the
+ * journal is read only will only be accurate if the journal is valid, due
+ * to short-circuiting that occurs on an invalid journal.
+ *
+ * @tsplus fluent fncts.io.Journal analyze
+ */
+export function analyzeJournal(journal: Journal): JournalAnalysis {
+  let result: JournalAnalysis = ReadOnly;
+  for (const entry of journal) {
+    result = entry[1].use((entry) => (entry.isInvalid() ? Invalid : entry.isChanged() ? ReadWrite : result));
+    if (result === Invalid) {
+      return result;
+    }
+  }
+  return result;
+}
+
+/**
+ * @tsplus static fncts.io.JournalOps emptyTodoMap
+ */
+export const emptyTodoMap = HashMap.makeDefault<TxnId, Todo>();
+
+/**
+ * Atomically collects and clears all the todos from any `TRef` that
+ * participated in the transaction.
+ *
+ * @tsplus getter fncts.io.Journal collectTodos
+ */
+export function collectTodos(journal: Journal): Map<TxnId, Todo> {
+  const allTodos: Map<TxnId, Todo> = new Map();
+
+  for (const entry of journal) {
+    const tref: Atomic<unknown> = entry[1].use((entry) => entry.tref as Atomic<unknown>);
+    const todos                 = tref.todo.get;
+    for (const todo of todos) {
+      allTodos.set(todo[0], todo[1]);
+    }
+    tref.todo.set(emptyTodoMap);
+  }
+
+  return allTodos;
+}
+
+/**
+ * Executes the todos in the current thread, sequentially.
+ *
+ * @tsplus fluent fncts.io.Journal execTodos
+ */
+export function execTodos(todos: Map<TxnId, Todo>) {
+  for (const todo of todos.values()) {
+    todo();
+  }
+}
+
+/**
+ * Runs all the todos.
+ *
+ * @tsplus fluent fncts.io.Journal completeTodos
+ */
+export function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>): Done<E, A> {
+  const todos = collectTodos(journal);
+  if (todos.size > 0) {
+    defaultScheduler(() => execTodos(todos));
+  }
+  return new Done(exit);
+}
+
+/**
+ * For the given transaction id, adds the specified todo effect to all
+ * `TRef` values.
+ *
+ * @tsplus fluent fncts.io.Journal addTodo
+ */
+export function addTodo(journal: Journal, txnId: TxnId, todoEffect: Todo): boolean {
+  let added = false;
+
+  for (const entry of journal.values()) {
+    const tref    = entry.use((entry) => entry.tref as Atomic<unknown>);
+    const oldTodo = tref.todo.get;
+    if (!oldTodo.has(txnId)) {
+      const newTodo = oldTodo.set(txnId, todoEffect);
+      tref.todo.set(newTodo);
+      added = true;
+    }
+  }
+
+  return added;
+}
+
+/**
+ * Finds all the new todo targets that are not already tracked in the `oldJournal`.
+ */
+export function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal): Journal {
+  const untracked: Journal = new Map();
+  for (const entry of newJournal) {
+    const key   = entry[0];
+    const value = entry[1];
+    if (
+      // We already tracked this one
+      !oldJournal.has(key) &&
+      // This `TRef` was created in the current transaction, so no need to
+      // add any todos to it, because it cannot be modified from the outside
+      // until the transaction succeeds; so any todo added to it would never
+      // succeed.
+      !value.use((_) => _.isNew)
+    ) {
+      untracked.set(key, value);
+    }
+  }
+  return untracked;
+}
+
+export function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>): TryCommit<E, A> {
+  const journal: Journal = new Map();
+  const value            = new STMDriver(stm, journal, fiberId, r).run();
+  const analysis         = journal.analyze();
+  if (analysis === ReadWrite) {
+    journal.commit();
+  } else if (analysis === Invalid) {
+    throw new Error("Bug: invalid journal");
+  }
+  switch (value._tag) {
+    case TExitTag.Retry: {
+      return new Suspend(journal);
+    }
+    case TExitTag.Succeed: {
+      return journal.completeTodos(Exit.succeed(value.value));
+    }
+    case TExitTag.Fail: {
+      return journal.completeTodos(Exit.fail(value.value));
+    }
+    case TExitTag.Halt: {
+      return journal.completeTodos(Exit.halt(value.value));
+    }
+    case TExitTag.Interrupt: {
+      return journal.completeTodos(Exit.interrupt(value.fiberId));
+    }
+  }
+}
+
+function tryCommit<R, E, A>(
+  fiberId: FiberId,
+  stm: STM<R, E, A>,
+  state: AtomicReference<CommitState<E, A>>,
+  r: Environment<R>,
+): TryCommit<E, A> {
+  const journal: Journal = new Map();
+  const value            = new STMDriver(stm, journal, fiberId, r).run();
+  const analysis         = journal.analyze();
+  if (analysis === ReadWrite) {
+    journal.commit();
+  } else if (analysis === Invalid) {
+    throw new Error("Bug: invalid journal");
+  }
+  state.set(CommitState.done(value));
+  switch (value._tag) {
+    case TExitTag.Retry: {
+      return new Suspend(journal);
+    }
+    case TExitTag.Succeed: {
+      return journal.completeTodos(Exit.succeed(value.value));
+    }
+    case TExitTag.Fail: {
+      return journal.completeTodos(Exit.fail(value.value));
+    }
+    case TExitTag.Halt: {
+      return journal.completeTodos(Exit.halt(value.value));
+    }
+    case TExitTag.Interrupt: {
+      return journal.completeTodos(Exit.interrupt(value.fiberId));
+    }
+  }
+}
+
+function completeTryCommit<R, E, A>(exit: Exit<E, A>, k: (_: IO<R, E, A>) => unknown) {
+  k(IO.fromExit(exit));
+}
+
+function suspendTryCommit<R, E, A>(
+  fiberId: FiberId,
+  stm: STM<R, E, A>,
+  txnId: TxnId,
+  state: AtomicReference<CommitState<E, A>>,
+  r: Environment<R>,
+  k: (_: IO<R, E, A>) => unknown,
+  accum: Journal,
+  journal: Journal,
+): void {
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    journal.addTodo(txnId, () => tryCommitAsync(undefined, fiberId, stm, txnId, state, r)(k));
+    if (isInvalid(journal)) {
+      const result = tryCommit(fiberId, stm, state, r);
+      switch (result._tag) {
+        case "Done": {
+          completeTryCommit(result.exit, k);
+          return;
+        }
+        case "Suspend": {
+          const untracked = untrackedTodoTargets(accum, result.journal);
+
+          if (untracked.size > 0) {
+            for (const entry of untracked) {
+              accum.set(entry[0], entry[1]);
+            }
+            // eslint-disable-next-line no-param-reassign
+            journal = untracked;
+          }
+
+          break;
+        }
+      }
+    } else {
+      return;
+    }
+  }
+}
+
+export function tryCommitAsync<R, E, A>(
+  journal: Journal | undefined,
+  fiberId: FiberId,
+  stm: STM<R, E, A>,
+  txnId: TxnId,
+  state: AtomicReference<CommitState<E, A>>,
+  r: Environment<R>,
+): (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);
+      } else {
+        const result = tryCommitSync(fiberId, stm, r);
+        switch (result._tag) {
+          case "Done": {
+            completeTryCommit(result.exit, k);
+            break;
+          }
+          case "Suspend": {
+            suspendTryCommit(fiberId, stm, txnId, state, r, k, result.journal, result.journal);
+            break;
+          }
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Determines if the journal is valid.
+ *
+ * @tsplus getter fncts.io.Journal isValid
+ */
+export function isValid(journal: Journal) {
+  let valid = true;
+  for (const entry of journal.values()) {
+    valid = entry.use((entry) => entry.isValid());
+    if (!valid) {
+      return valid;
+    }
+  }
+  return valid;
+}
+
+/**
+ * Determines if the journal is invalid.
+ *
+ * @tsplus getter fncts.io.Journal isInvalid
+ */
+export function isInvalid(journal: Journal) {
+  return !journal.isValid;
+}

package/_src/STM/internal/TryCommit.ts

@@ -0,0 +1,23 @@
+import type { Journal } from "./Journal.js";
+
+export const TryCommitTypeId = Symbol.for("fncts.io.TryCommit");
+export type TryCommitTypeId = typeof TryCommitTypeId;
+
+export type TryCommit<E, A> = Done<E, A> | Suspend;
+
+export const enum TryCommitTag {
+  Done = "Done",
+  Suspend = "Suspend",
+}
+
+export class Done<E, A> {
+  readonly _typeId: TryCommitTypeId = TryCommitTypeId;
+  readonly _tag                     = TryCommitTag.Done;
+  constructor(readonly exit: Exit<E, A>) {}
+}
+
+export class Suspend {
+  readonly _typeId: TryCommitTypeId = TryCommitTypeId;
+  readonly _tag                     = TryCommitTag.Suspend;
+  constructor(readonly journal: Journal) {}
+}

package/_src/STM/internal/Versioned.ts

@@ -0,0 +1,7 @@
+export const VersionedTypeId = Symbol.for("fncts.io.Versioned");
+export type VersionedTypeId = typeof VersionedTypeId;
+
+export class Versioned<A> {
+  readonly _typeId: VersionedTypeId = VersionedTypeId;
+  constructor(readonly value: A) {}
+}

package/_src/STM.ts

@@ -0,0 +1,10 @@
+// codegen:start { preset: barrel, include: STM/*.ts }
+export * from "./STM/api.js";
+export * from "./STM/definition.js";
+export * from "./STM/driver.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: STM/api/*.ts }
+export * from "./STM/api/core-api.js";
+export * from "./STM/api/core-constructors.js";
+// codegen:end

package/_src/Schedule/Decision.ts

@@ -0,0 +1,51 @@
+import type { Interval } from "./Interval.js";
+
+export const enum DecisionTag {
+  Continue = "Continue",
+  Done = "Done",
+}
+
+export class Continue {
+  readonly _tag = DecisionTag.Continue;
+  constructor(readonly interval: Interval) {}
+}
+
+export class Done {
+  readonly _tag = DecisionTag.Done;
+}
+
+/**
+ * @tsplus type fncts.io.Schedule.Decision
+ */
+export type Decision = Continue | Done;
+
+/**
+ * @tsplus type fncts.io.Schedule.DecisionOps
+ */
+export interface DecisionOps {}
+
+export const Decision: DecisionOps = {};
+
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps Done
+ */
+export const done: Decision = new Done();
+
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps Continue
+ */
+export function continue_(interval: Interval): Decision {
+  return new Continue(interval);
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Decision match
+ */
+export function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Interval) => B): A | B {
+  switch (self._tag) {
+    case DecisionTag.Continue:
+      return onContinue(self.interval);
+    case DecisionTag.Done:
+      return onDone();
+  }
+}

package/_src/Schedule/Driver.ts

@@ -0,0 +1,24 @@
+/**
+ * @tsplus type fncts.io.Schedule.Driver
+ * @tsplus companion fncts.io.Schedule.DriverOps
+ */
+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 reset: UIO<void>,
+    readonly state: UIO<State>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.DriverOps __call
+ */
+export function makeDriver<State, Env, In, Out>(
+  next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>,
+  last: IO<unknown, NoSuchElementError, Out>,
+  reset: UIO<void>,
+  state: UIO<State>,
+): Driver<State, Env, In, Out> {
+  return new Driver(next, last, reset, state);
+}

package/_src/Schedule/Interval.ts

@@ -0,0 +1,103 @@
+/**
+ * @tsplus type fncts.io.Schedule.Interval
+ * @tsplus companion fncts.io.Schedule.IntervalOps
+ */
+export class Interval {
+  constructor(readonly startMilliseconds: number, readonly endMilliseconds: number) {}
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps after
+ */
+export function after(start: number): Interval {
+  return Interval(start, Number.MAX_SAFE_INTEGER);
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps before
+ */
+export function before(end: number): Interval {
+  return Interval(Number.MIN_SAFE_INTEGER, end);
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps empty
+ */
+export const empty: Interval = new Interval(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isEmpty
+ */
+export function isEmpty(self: Interval): boolean {
+  return self.startMilliseconds >= self.endMilliseconds;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval intersect
+ */
+export function intersect_(self: Interval, that: Interval): Interval {
+  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
+  const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
+  return Interval(start, end);
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval lt
+ * @tsplus operator fncts.io.Schedule.Interval <
+ */
+export function lt_(self: Interval, that: Interval): boolean {
+  return self.min(that) === self;
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps __call
+ */
+export function makeInterval(start: number, end: number): Interval {
+  if (start <= end) return Interval(start, end);
+  else return Interval.empty;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval max
+ */
+export function max_(self: Interval, that: Interval): Interval {
+  const m = self.min(that);
+  if (m === self) return that;
+  else return self;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval min
+ */
+export function min_(self: Interval, that: Interval): Interval {
+  if (self.endMilliseconds <= that.startMilliseconds) return self;
+  if (that.endMilliseconds <= self.startMilliseconds) return that;
+  if (self.startMilliseconds < that.startMilliseconds) return self;
+  if (that.startMilliseconds < self.startMilliseconds) return that;
+  if (self.endMilliseconds <= that.endMilliseconds) return self;
+  return that;
+}
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
+ */
+export function isNonEmpty(self: Interval): boolean {
+  return !self.isEmpty;
+}
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval size
+ */
+export function size(self: Interval): number {
+  return self.endMilliseconds - self.startMilliseconds;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval union
+ */
+export function union_(self: Interval, that: Interval): Maybe<Interval> {
+  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
+  const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
+  if (istart <= iend) return Nothing();
+  else return Just(Interval(istart, iend));
+}

package/_src/Schedule/api/driver.ts

@@ -0,0 +1,38 @@
+import { Driver } from "@fncts/io/Schedule/Driver";
+
+/**
+ * @tsplus getter fncts.io.Schedule driver
+ */
+export function driver<State, Env, In, Out>(
+  schedule: Schedule.WithState<State, Env, In, Out>,
+  __tsplusTrace?: string,
+): 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* _(
+          decision.match(
+            () => ref.set([Just(out), state1]).apSecond(IO.failNow(Nothing() as Nothing)),
+            (interval) =>
+              ref
+                .set([Just(out), state1])
+                .apSecond(Clock.sleep(interval.startMilliseconds - now))
+                .as(out),
+          ),
+        );
+      });
+
+    const last = ref.get.flatMap(([mOut, _]) =>
+      mOut.match(() => IO.failNow(new NoSuchElementError("There is no value left")), IO.succeedNow),
+    );
+
+    const reset = ref.set([Nothing(), schedule.initial]);
+
+    const state = ref.get.map(([_, state]) => state);
+
+    return Driver(next, last, reset, state);
+  });
+}