@fncts/io 0.0.21 → 0.0.22

package/_src/RefSubject/api.ts

@@ -0,0 +1,240 @@
+import { tuple } from "@fncts/base/data/function";
+import { Emitter } from "@fncts/io/Push";
+import { AtomicRefSubject } from "@fncts/io/RefSubject/Atomic";
+
+import { RefSubject } from "./definition.js";
+import { RefSubjectInternal } from "./definition.js";
+import { concrete } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps unsafeMake
+ */
+export function unsafeMake<A>(initial: A): RefSubject<never, never, A, A> {
+  return new AtomicRefSubject(initial);
+}
+
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps make
+ * @tsplus static fncts.io.Push.RefSubjectOps __call
+ */
+export function make<A>(initial: Lazy<A>): UIO<RefSubject<never, never, A, A>> {
+  return IO(RefSubject.unsafeMake(initial()));
+}
+
+/**
+ * Reads the value from the `Ref`.
+ *
+ * @tsplus getter fncts.io.Push.RefSubject get
+ */
+export function get<R, E, A, B>(self: RefSubject<R, E, A, B>, __tsplusTrace?: string): IO<R, never, B> {
+  concrete(self);
+  return self.get;
+}
+
+/**
+ * Writes a new value to the `Ref`, with a guarantee of immediate
+ * consistency (at some cost to performance).
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject set
+ */
+export function set<A>(a: A, __tsplusTrace?: string) {
+  return <R, E, B>(self: RefSubject<R, E, A, B>): IO<R, never, void> => {
+    concrete(self);
+    return self.set(a);
+  };
+}
+
+class Dimap<R, E, A, B, C, D> extends RefSubjectInternal<R, E, C, D> {
+  constructor(readonly ref: RefSubjectInternal<R, E, A, B>, readonly f: (c: C) => A, readonly g: (b: B) => D) {
+    super();
+  }
+
+  get get(): IO<R, never, D> {
+    return this.ref.get.map(this.g);
+  }
+
+  set(value: C): IO<R, never, void> {
+    return this.ref.set(this.f(value));
+  }
+
+  modify<F>(f: (d: D) => readonly [F, C], __tsplusTrace?: string | undefined): IO<R, never, F> {
+    return this.get.flatMap((c) => {
+      const o = f(c);
+      return this.set(o[1]) > IO.succeedNow(o[0]);
+    });
+  }
+
+  run<R1>(emitter: Emitter<R1, E, D>): IO<Scope | R | R1, never, void> {
+    return this.ref.run(
+      Emitter(
+        (value) => emitter.emit(this.g(value)),
+        (cause) => emitter.failCause(cause),
+        emitter.end,
+      ),
+    );
+  }
+
+  emit(value: C): IO<R, never, void> {
+    return this.ref.emit(this.f(value));
+  }
+
+  failCause(cause: Cause<E>): IO<R, never, void> {
+    return this.ref.failCause(cause);
+  }
+
+  end: IO<R, never, void> = this.ref.end;
+}
+
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified functions.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject dimap
+ */
+export function dimap<A, B, C, D>(f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, B>): RefSubject<R, E, C, D> => {
+    concrete(self);
+    return new Dimap(self, f, g);
+  };
+}
+
+/**
+ * Transforms the `set` value of the `Ref` with the specified function.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject contramap
+ */
+export function contramap<A, C>(f: (_: C) => A, __tsplusTrace?: string) {
+  return <R, E, B>(self: RefSubject<R, E, A, B>): RefSubject<R, E, C, B> => {
+    return self.dimap(f, Function.identity);
+  };
+}
+
+/**
+ * Transforms the `get` value of the `Ref` with the specified function.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject map
+ */
+export function map<B, C>(f: (_: B) => C, __tsplusTrace?: string) {
+  return <R, E, A>(ref: RefSubject<R, E, A, B>): RefSubject<R, E, A, C> => {
+    return ref.dimap(Function.identity, f);
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified function, which
+ * computes a return value for the modification. This is a more powerful
+ * version of `update`.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject modify
+ */
+export function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, B> => {
+    concrete(self);
+    return self.modify(f);
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified partial function,
+ * which computes a return value for the modification if the function is
+ * defined on the current value otherwise it returns a default value. This
+ * is a more powerful version of `updateJust`.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject modifyJust
+ */
+export function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, B> => {
+    return self.modify((a) => f(a).getOrElse(tuple(def, a)));
+  };
+}
+
+/**
+ * Atomically writes the specified value to the `Ref`, returning the value
+ * immediately before modification.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndSet
+ */
+export function getAndSet<A>(a: A, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, A> => {
+    return self.modify((a0) => tuple(a0, a));
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified function, returning
+ * the value immediately before modification.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdate
+ */
+export function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, E, A> => {
+    return self.modify((a0) => tuple(a0, f(a0)));
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified partial function,
+ * returning the value immediately before modification. If the function is
+ * undefined on the current value it doesn't change it.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdateJust
+ */
+export function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, A> => {
+    return self.modify((a0) => tuple(a0, f(a0).getOrElse(a0)));
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified function.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject update
+ */
+export function update<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, void> => {
+    return self.modify((a0) => tuple(undefined, f(a0)));
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified function and returns
+ * the updated value.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject updateAndGet
+ */
+export function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>) => {
+    return self.modify((a0) => {
+      const r = f(a0);
+      return tuple(r, r);
+    });
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified partial function. If
+ * the function is undefined on the current value it doesn't change it.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject updateJust
+ */
+export function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, void> => {
+    return self.modify((a0) => tuple(undefined, f(a0).getOrElse(a0)));
+  };
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified partial function. If
+ * the function is undefined on the current value it returns the old value
+ * without changing it.
+ *
+ * @tsplus pipeable fncts.io.Push.RefSubject updateJustAndGet
+ */
+export function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <R, E>(self: RefSubject<R, E, A, A>): IO<R, never, A> => {
+    return self.modify((a0) => {
+      const r = f(a0).getOrElse(a0);
+      return tuple(r, r);
+    });
+  };
+}

package/_src/RefSubject/definition.ts

@@ -0,0 +1,62 @@
+import type { Emitter } from "../Push.js";
+import type { Push } from "../Push.js";
+import type { ModifiableRef, ReadableRef, WritableRef } from "../Ref.js";
+import type { SynchronizedRefSubject } from "@fncts/io/RefSubject/Synchronized/definition";
+
+/**
+ * @tsplus type fncts.io.Push.RefSubject
+ */
+export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Emitter<R, E, A> {
+  readonly _A: (_: A) => B;
+}
+
+/**
+ * @tsplus type fncts.io.Push.RefSubjectOps
+ */
+export interface RefSubjectOps {}
+
+export const RefSubject: RefSubjectOps = {};
+
+export declare namespace RefSubject {
+  export type Synchronized<R, E, A, B> = SynchronizedRefSubject<R, E, A, B>;
+}
+
+export abstract class RefSubjectInternal<R, E, A, B>
+  implements
+    ReadableRef<R, never, B>,
+    WritableRef<R, never, A>,
+    ModifiableRef<R, R, never, never, A, B>,
+    Push<R, E, B>,
+    Emitter<R, E, A>
+{
+  declare [Ref._RA]: () => R;
+  declare [Ref._RB]: () => R;
+  declare [Ref._EA]: () => never;
+  declare [Ref._EB]: () => never;
+  declare [Ref._A]: (_: A) => void;
+  declare [Ref._B]: () => B;
+  declare _R: (_: never) => R;
+  declare _E: (_: never) => E;
+  declare _A: (_: A) => B;
+
+  abstract get get(): IO<R, never, B>;
+
+  abstract set(value: A): IO<R, never, void>;
+
+  abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<R, never, C>;
+
+  abstract run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+
+  abstract failCause(cause: Cause<E>): IO<R, never, void>;
+
+  abstract emit(value: A): IO<R, never, void>;
+
+  abstract end: IO<R, never, void>;
+}
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B> {
+  //
+}

package/_src/RefSubject.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ./RefSubject/*.ts }
+export * from "./RefSubject/api.js";
+export * from "./RefSubject/Atomic.js";
+export * from "./RefSubject/definition.js";
+// codegen:end

package/_src/RuntimeConfig.ts

@@ -1,35 +1,6 @@
-export const RuntimeConfigFlag = {
-  EnableCurrentFiber: Symbol.for("fncta.data.RuntimeConfigFlag.EnableCurrentFiber"),
-  LogRuntime: Symbol.for("fncta.data.RuntimeConfigFlag.LogRuntime"),
-  SuperviseOperations: Symbol.for("fncta.data.RuntimeConfigFlag.SuperviseOperations"),
-  TrackRuntimeMetrics: Symbol.for("fncts.RuntimeConfigFlag.TrackRuntimeMetrics"),
-  EnableFiberRoots: Symbol.for("fncta.data.RuntimeConfigFlag.EnableFiberRoots"),
-} as const;
-
-export type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
-
 export class RuntimeConfig extends CaseClass<{
   readonly reportFailure: (e: Cause<unknown>) => void;
   readonly supervisor: Supervisor<any>;
-  readonly flags: RuntimeConfigFlags;
   readonly yieldOpCount: number;
   readonly logger: Logger<string, any>;
 }> {}
-
-/**
- * @tsplus companion fncts.RuntimeConfigFlags
- */
-export class RuntimeConfigFlags {
-  constructor(readonly flags: HashSet<RuntimeConfigFlag>) {}
-  add(flag: RuntimeConfigFlag) {
-    return new RuntimeConfigFlags(this.flags.add(flag));
-  }
-  isEnabled(flag: RuntimeConfigFlag): boolean {
-    return this.flags.has(flag);
-  }
-}
-
-/**
- * @tsplus static fncts.RuntimeConfigFlags empty
- */
-export const empty = new RuntimeConfigFlags(HashSet.makeDefault());

package/_src/RuntimeFlag.ts

@@ -0,0 +1,10 @@
+export const enum RuntimeFlag {
+  Interruption = 1 << 0,
+  CurrentFiber = 1 << 1,
+  OpLog = 1 << 2,
+  OpSupervision = 1 << 3,
+  RuntimeMetrics = 1 << 4,
+  FiberRoots = 1 << 5,
+  WindDown = 1 << 6,
+  CooperativeYielding = 1 << 7,
+}

package/_src/RuntimeFlags/Patch.ts

@@ -0,0 +1,79 @@
+import type { RuntimeFlag } from "../RuntimeFlag.js";
+
+import { RuntimeFlags } from "./RuntimeFlags.js";
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatch
+ */
+export type RuntimeFlagsPatch = number & {
+  readonly RuntimeFlagsPatch: unique symbol;
+};
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatchOps
+ */
+export interface RuntimeFlagsPatchOps {}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps Patch
+ */
+export const RuntimeFlagsPatch: RuntimeFlagsPatchOps = Newtype();
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsPatchOps __call
+ */
+export function makeRuntimeFlagsPatch(active: number, enabled: number): RuntimeFlags.Patch {
+  return ((active << 0) + ((enabled & active) << 16)) as RuntimeFlags.Patch;
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps enable
+ */
+export function mkEnable(flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(flag, flag);
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps disable
+ */
+export function mkDisable(flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(flag, 0);
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isActive
+ */
+export function isActive(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean {
+  return (active(patch) & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isEnabled
+ */
+export function isEnabledPatch(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean {
+  return patch.isActive(flag) && (enabled(patch) & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch patch
+ */
+export function patch(patch: RuntimeFlags.Patch, flags: RuntimeFlags): RuntimeFlags {
+  return ((flags & (~active(patch) | enabled(patch))) | (active(patch) & enabled(patch))) as RuntimeFlags;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch exclude
+ */
+export function exclude(patch: RuntimeFlags.Patch, flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(active(patch) & ~flag, enabled(patch));
+}
+
+const base = 0xffffffff | 0;
+
+function active(patch: RuntimeFlags.Patch): number {
+  return (patch >> 0) & base;
+}
+
+function enabled(patch: RuntimeFlags.Patch): number {
+  return (patch >> 16) & base;
+}

package/_src/RuntimeFlags/RuntimeFlags.ts

@@ -0,0 +1,112 @@
+import type { RuntimeFlagsPatch } from "./Patch.js";
+
+import { RuntimeFlag } from "../RuntimeFlag.js";
+
+/**
+ * @tsplus type fncts.io.RuntimeFlags
+ */
+export type RuntimeFlags = number & {
+  readonly RuntimeFlags: unique symbol;
+};
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsOps
+ */
+export interface RuntimeFlagsOps {}
+
+export const RuntimeFlags: RuntimeFlagsOps = Newtype();
+
+export declare namespace RuntimeFlags {
+  type Patch = RuntimeFlagsPatch;
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps __call
+ */
+export function makeRuntimeFlags(...flags: ReadonlyArray<RuntimeFlag>): RuntimeFlags {
+  return flags.reduce((b, a) => b | a, 0) as RuntimeFlags;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags isEnabled
+ */
+export function isEnabled(flags: RuntimeFlags, flag: RuntimeFlag): boolean {
+  return (flags & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags enable
+ */
+export function enable(flags: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags {
+  return (flags | flag) as RuntimeFlags;
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags cooperativeYielding
+ */
+export function cooperativeYielding(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.CooperativeYielding);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags currentFiber
+ */
+export function currentFiber(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.CurrentFiber);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags fiberRoots
+ */
+export function fiberRoots(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.FiberRoots);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruption
+ */
+export function interruption(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.Interruption);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags windDown
+ */
+export function windDown(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.WindDown);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags opSupervision
+ */
+export function opSpervision(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.OpSupervision);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruptible
+ */
+export function interruptible(flags: RuntimeFlags): boolean {
+  return interruption(flags) && !windDown(flags);
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags diff
+ */
+export function diff(oldValue: RuntimeFlags, newValue: RuntimeFlags) {
+  return RuntimeFlags.Patch(oldValue ^ newValue, newValue);
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps none
+ */
+export const none = 0 as RuntimeFlags;
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps default
+ */
+export const defaultRuntimeFlags = RuntimeFlags(
+  RuntimeFlag.FiberRoots,
+  RuntimeFlag.Interruption,
+  RuntimeFlag.CooperativeYielding,
+);

package/_src/RuntimeFlags.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: RuntimeFlags/*.ts }
+export * from "./RuntimeFlags/Patch.js";
+export * from "./RuntimeFlags/RuntimeFlags.js";
+// codegen:end

package/_src/STM/api.ts

@@ -92,7 +92,7 @@ export function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R
 export function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.environmentWithIO((r: Environment<R>) =>
     FiberRef.currentScheduler.getWith((scheduler) =>
-      IO.deferWith((_, fiberId) => {
+      IO.fiberId.flatMap((fiberId) => {
         const result = tryCommitSync(fiberId, stm, r, scheduler);
         switch (result._tag) {
           case TryCommitTag.Done: {

package/_src/STM/internal/Journal.ts

@@ -88,7 +88,7 @@ export function analyzeJournal(journal: Journal): JournalAnalysis {
 /**
  * @tsplus static fncts.io.JournalOps emptyTodoMap
  */
-export const emptyTodoMap = HashMap.makeDefault<TxnId, Todo>();
+export const emptyTodoMap = HashMap.empty<TxnId, Todo>();
 
 /**
  * Atomically collects and clears all the todos from any `TRef` that

package/_src/Schedule/api/driver.ts

@@ -15,11 +15,11 @@ export function driver<State, Env, In, Out>(
         const [state1, out, decision] = _(schedule.step(now, inp, state));
         return _(
           decision.match(
-            () => ref.set([Just(out), state1]).apSecond(IO.failNow(Nothing() as Nothing)),
+            () => ref.set([Just(out), state1]).zipRight(IO.failNow(Nothing() as Nothing)),
             (interval) =>
               ref
                 .set([Just(out), state1])
-                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.start)))
+                .zipRight(Clock.sleep(Duration.fromInterval(now, interval.start)))
                 .as(out),
           ),
         );