@fncts/io 0.0.20 → 0.0.22

package/Ref/api/filter.d.ts

@@ -1,20 +1,21 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { PRef } from "../definition.js";
 /**
  * Filters the `set` value of the `Ref` with the specified predicate,
  * returning a `Ref` with a `set` value that succeeds if the predicate is
  * satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref filterInput
- * @tsplus fluent fncts.io.Ref.Synchronized filterInput
+ * @tsplus pipeable fncts.io.Ref filterInput
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterInput
  * @tsplus location "@fncts/io/Ref/api/filter"
  */
-export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean, __tsplusTrace?: string): PRef<RA, RB, Maybe<EA>, EB, A1, B>;
+export declare function filterInput<A, A1 extends A>(p: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, import("@fncts/base/data/Maybe.js").Maybe<EA>, EB, A1, B>;
 /**
  * Filters the `get` value of the `Ref` with the specified predicate,
  * returning a `Ref` with a `get` value that succeeds if the predicate is
  * satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref filterOutput
- * @tsplus fluent fncts.io.Ref.Synchronized filterOutput
+ * @tsplus pipeable fncts.io.Ref filterOutput
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterOutput
  * @tsplus location "@fncts/io/Ref/api/filter"
  */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => boolean, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, B>;
+export declare function filterOutput<RA, RB, EA, EB, A, B>(p: Predicate<B>, __tsplusTrace?: string): (self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, Maybe<EB>, A, B>;

package/Ref/api/get.d.ts

@@ -6,4 +6,4 @@ import type { PRef } from "../definition.js";
  * @tsplus getter fncts.io.Ref.Synchronized get
  * @tsplus location "@fncts/io/Ref/api/get"
  */
-export declare function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
+export declare function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B>;

package/Ref/api/match.d.ts

@@ -6,8 +6,8 @@ import type { PRef } from "../definition.js";
  * and value types of the `Ref`. For most use cases one of the more specific
  * combinators implemented in terms of `match` will be more ergonomic but this
  * method is extremely useful for implementing new combinators.
- * @tsplus fluent fncts.io.Ref match
- * @tsplus fluent fncts.io.Ref.Synchronized match
+ * @tsplus pipeable fncts.io.Ref match
+ * @tsplus pipeable fncts.io.Ref.Synchronized match
  * @tsplus location "@fncts/io/Ref/api/match"
  */
-export declare function match_<RA, RB, EA, EB, A, B, EC, ED, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;
+export declare function match<EA, EB, A, B, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): <RA, RB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC, ED, C, D>;

package/Ref/api/matchAll.d.ts

@@ -8,4 +8,4 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized matchAll
  * @tsplus location "@fncts/io/Ref/api/matchAll"
  */
-export declare function matchAll_<RA, RB, EA, EB, A, B, EC, ED, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;
+export declare function matchAll<EA, EB, A, B, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): <RA, RB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA | RB, RB, EC, ED, C, D>;

package/Ref/api/modify.d.ts

@@ -5,75 +5,75 @@ import type { PRef } from "../definition.js";
  * 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 fluent fncts.io.Ref modify
- * @tsplus fluent fncts.io.Ref.Synchronized modify
+ * @tsplus pipeable fncts.io.Ref modify
+ * @tsplus pipeable fncts.io.Ref.Synchronized modify
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modify_<RA, RB, EA, EB, B, A>(ref: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, B>;
 /**
  * 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 fluent fncts.io.Ref modifyJust
- * @tsplus fluent fncts.io.Ref.Synchronized modifyJust
+ * @tsplus pipeable fncts.io.Ref modifyJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized modifyJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modifyJust_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, B>;
 /**
  * Atomically writes the specified value to the `Ref`, returning the value
  * immediately before modification.
- * @tsplus fluent fncts.io.Ref getAndSet
- * @tsplus fluent fncts.io.Ref.Synchronized getAndSet
+ * @tsplus pipeable fncts.io.Ref getAndSet
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndSet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function, returning
  * the value immediately before modification.
- * @tsplus fluent fncts.io.Ref getAndUpdate
- * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdate
+ * @tsplus pipeable fncts.io.Ref getAndUpdate
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdate
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdate_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
 /**
  * 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 fluent fncts.io.Ref getAndUpdateJust
- * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdateJust
+ * @tsplus pipeable fncts.io.Ref getAndUpdateJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref update
- * @tsplus fluent fncts.io.Ref.Synchronized update
+ * @tsplus pipeable fncts.io.Ref update
+ * @tsplus pipeable fncts.io.Ref.Synchronized update
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function update_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, void>;
 /**
  * Atomically modifies the `Ref` with the specified function and returns
  * the updated value.
- * @tsplus fluent fncts.io.Ref updateAndGet
- * @tsplus fluent fncts.io.Ref.Synchronized updateAndGet
+ * @tsplus pipeable fncts.io.Ref updateAndGet
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified partial function. If
  * the function is undefined on the current value it doesn't change it.
- * @tsplus fluent fncts.io.Ref updateJust
- * @tsplus fluent fncts.io.Ref.Synchronized updateJust
+ * @tsplus pipeable fncts.io.Ref updateJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, void>;
 /**
  * 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 fluent fncts.io.Ref updateJustAndGet
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGet
+ * @tsplus pipeable fncts.io.Ref updateJustAndGet
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJustAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;

package/Ref/api/set.d.ts

@@ -3,8 +3,8 @@ import type { PRef } from "../definition.js";
 /**
  * Writes a new value to the `Ref`, with a guarantee of immediate
  * consistency (at some cost to performance).
- * @tsplus fluent fncts.io.Ref set
- * @tsplus fluent fncts.io.Ref.Synchronized set
+ * @tsplus pipeable fncts.io.Ref set
+ * @tsplus pipeable fncts.io.Ref.Synchronized set
  * @tsplus location "@fncts/io/Ref/api/set"
  */
-export declare function set_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => import("../../IO.js").IO<RA, EA, void>;

package/Ref/constructors.d.ts

@@ -1,6 +1,6 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 /**
  * @tsplus static fncts.io.RefOps make
  * @tsplus location "@fncts/io/Ref/constructors"

package/Ref/definition.d.ts

@@ -1,22 +1,21 @@
-import { Either } from "@fncts/base/data/Either/definition";
 import { IO } from "@fncts/io/IO/definition";
-import type { Atomic as Atomic_ } from "./Atomic/Atomic.js";
-import type { Derived } from "./Derived.js";
-import type { DerivedAll } from "./DerivedAll.js";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { Atomic as Atomic_ } from "./Atomic.js";
 import type * as Synchro from "./Synchronized/definition.js";
+import { _A, _B, _EA, _EB, _RA, _RB } from "./symbols.js";
 export declare const RefTypeId: unique symbol;
 export type RefTypeId = typeof RefTypeId;
 /**
  * @tsplus type fncts.io.Ref
  */
 export interface PRef<RA, RB, EA, EB, A, B> {
-    readonly _U: RefTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    readonly [RefTypeId]: RefTypeId;
+    readonly [_RA]: () => RA;
+    readonly [_RB]: () => RB;
+    readonly [_EA]: () => EA;
+    readonly [_EB]: () => EB;
+    readonly [_A]: (_: A) => void;
+    readonly [_B]: () => B;
 }
 export type Ref<A> = PRef<never, never, never, never, A, A>;
 export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
@@ -36,14 +35,35 @@ export declare namespace Ref {
 export interface RefOps {
 }
 export declare const Ref: RefOps;
-export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B> {
-    _U: RefTypeId;
-    _RA: () => RA;
-    _RB: () => RB;
-    _EA: () => EA;
-    _EB: () => EB;
-    _A: (_: A) => void;
-    _B: () => B;
+export interface ReadableRef<RB, EB, B> {
+    readonly [_RB]: () => RB;
+    readonly [_EB]: () => EB;
+    readonly [_B]: () => B;
+    readonly get: IO<RB, EB, B>;
+}
+export interface WritableRef<RA, EA, A> {
+    readonly [_RA]: () => RA;
+    readonly [_EA]: () => EA;
+    readonly [_A]: (_: A) => void;
+    set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+}
+export interface ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [_RA]: () => RA;
+    readonly [_RB]: () => RB;
+    readonly [_EA]: () => EA;
+    readonly [_EB]: () => EB;
+    readonly [_A]: (_: A) => void;
+    readonly [_B]: () => B;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
+}
+export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B>, ReadableRef<RB, EB, B>, WritableRef<RA, EA, A>, ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [RefTypeId]: RefTypeId;
+    [_RA]: () => RA;
+    [_RB]: () => RB;
+    [_EA]: () => EA;
+    [_EB]: () => EB;
+    [_A]: (_: A) => void;
+    [_B]: () => B;
     /**
      * Folds over the error and value types of the `Ref`. This is a highly
      * polymorphic method that is capable of arbitrarily transforming the error
@@ -67,8 +87,14 @@ export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<
      * consistency (at some cost to performance).
      */
     abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+    /**
+     * Atomically modifies the `Ref` with the specified function, which
+     * computes a return value for the modification. This is a more powerful
+     * version of `update`.
+     */
+    abstract modify<C>(f: (a: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
 /**
  * @tsplus macro remove
  */
-export declare function concrete<RA, RB, EA, EB, A, B>(_: PRef<RA, RB, EA, EB, A, B>): asserts _ is Atomic_<A | B> | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B> | Synchro.PSynchronizedInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PRef<RA, RB, EA, EB, A, B>): asserts _ is RefInternal<RA, RB, EA, EB, A, B>;

package/Ref/symbols.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @tsplus static fncts.io.RefOps _RA
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _RA: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _RB
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _RB: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _EA
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _EA: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _EB
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _EB: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _A
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _A: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _B
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _B: unique symbol;

package/Ref.d.ts

@@ -4,6 +4,8 @@ export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
 export * from "./Ref/Derived.js";
 export * from "./Ref/DerivedAll.js";
+export * from "./Ref/symbols.js";
+export * from "./Ref/Synchronized.js";
 export * from "./Ref/Synchronized/api.js";
 export * from "./Ref/Synchronized/constructors.js";
 export * from "./Ref/Synchronized/definition.js";

package/RefSubject/Atomic.d.ts

@@ -0,0 +1,36 @@
+import { Just } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Emitter } from "@fncts/io/Push";
+import { Hold } from "@fncts/io/Push";
+import { Atomic } from "@fncts/io/Ref";
+import { RefSubjectInternal } from "@fncts/io/RefSubject";
+export declare class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
+    readonly initial: A;
+    readonly stream: Hold<never, E, A>;
+    readonly maybeRef: Atomic<import("@fncts/base/data/Maybe").Maybe<A>>;
+    readonly ref: AtomicEmitRef<E, A>;
+    constructor(initial: A);
+    get get(): import("../IO").UIO<A>;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<E, A, B>(this: AtomicRefSubject<E, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<never, never, B>;
+    run<R>(emitter: Emitter<R, E, A>): IO<Scope | R, never, unknown>;
+    emit(value: A): IO<never, never, void>;
+    failCause(cause: Cause<E>): IO<never, never, void>;
+    end: IO<never, never, void>;
+    unsafeEmit(value: A): void;
+    unsafeFailCause(cause: Cause<E>): void;
+    unsafeEnd(): void;
+}
+declare class AtomicEmitRef<E, A> extends Atomic<A> {
+    readonly ref: Atomic<A>;
+    readonly emitter: Emitter<never, E, A>;
+    constructor(ref: Atomic<A>, emitter: Emitter<never, E, A>);
+    get get(): import("../IO").UIO<A>;
+    get unsafeGet(): A;
+    unsafeSet(value: A): void;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../IO").IO<never, never, B>;
+}
+export {};

package/RefSubject/Synchronized/api.d.ts

@@ -0,0 +1,9 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { RefSubject } from "@fncts/io/RefSubject";
+/**
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps make
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps __call
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/api"
+ */
+export declare function make<A>(initial: Lazy<A>): UIO<RefSubject.Synchronized<never, never, A, A>>;

package/RefSubject/Synchronized/definition.d.ts

@@ -0,0 +1,40 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import type { RefSubject } from "../definition.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { Emitter } from "@fncts/io/Push";
+import type { Scope } from "@fncts/io/Scope";
+import { IO } from "@fncts/io/IO";
+import { RefSubjectInternal } from "../definition.js";
+export declare const SynchronizedRefSubjectTypeId: unique symbol;
+export type SynchronizedRefSubjectTypeId = typeof SynchronizedRefSubjectTypeId;
+/**
+ * @tsplus type fncts.io.Push.RefSubject.Synchronized
+ */
+export interface SynchronizedRefSubject<R, E, A, B> extends RefSubject<R, E, A, B> {
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+}
+/**
+ * @tsplus type fncts.io.Push.RefSubject.SynchronizedOps
+ */
+export interface SynchronizedRefSubjectOps {
+}
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps Synchronized
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/definition"
+ */
+export declare const Synchronized: SynchronizedRefSubjectOps;
+export declare class SynchronizedRefSubjectInternal<R, E, A, B> extends RefSubjectInternal<R, E, A, B> implements SynchronizedRefSubject<R, E, A, B> {
+    readonly semaphore: TSemaphore;
+    readonly ref: RefSubjectInternal<R, E, A, B>;
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+    constructor(semaphore: TSemaphore, ref: RefSubjectInternal<R, E, A, B>);
+    get get(): IO<R, never, B>;
+    set(a: A, __tsplusTrace?: string | undefined): IO<R, never, void>;
+    run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<R, never, C>;
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<R | R1, E1, C>;
+    emit(value: A): IO<R, never, void>;
+    failCause(cause: Cause<E>): IO<R, never, void>;
+    end: IO<R, never, void>;
+    withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+}

package/RefSubject/api.d.ts

@@ -0,0 +1,116 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { RefSubject } from "./definition.js";
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps unsafeMake
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function unsafeMake<A>(initial: A): RefSubject<never, never, A, A>;
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps make
+ * @tsplus static fncts.io.Push.RefSubjectOps __call
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function make<A>(initial: Lazy<A>): UIO<RefSubject<never, never, A, A>>;
+/**
+ * Reads the value from the `Ref`.
+ * @tsplus getter fncts.io.Push.RefSubject get
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function get<R, E, A, B>(self: RefSubject<R, E, A, B>, __tsplusTrace?: string): IO<R, never, B>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function set<A>(a: A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => import("../IO.js").IO<R, never, void>;
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified functions.
+ * @tsplus pipeable fncts.io.Push.RefSubject dimap
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function dimap<A, B, C, D>(f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, B>) => RefSubject<R, E, C, D>;
+/**
+ * Transforms the `set` value of the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject contramap
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function contramap<A, C>(f: (_: C) => A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => RefSubject<R, E, C, B>;
+/**
+ * Transforms the `get` value of the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject map
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function map<B, C>(f: (_: B) => C, __tsplusTrace?: string): <R, E, A>(ref: RefSubject<R, E, A, B>) => RefSubject<R, E, A, C>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+/**
+ * Atomically writes the specified value to the `Ref`, returning the value
+ * immediately before modification.
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndSet
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function, returning
+ * the value immediately before modification.
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdate
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, E, A>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject update
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+/**
+ * Atomically modifies the `Ref` with the specified function and returns
+ * the updated value.
+ * @tsplus pipeable fncts.io.Push.RefSubject updateAndGet
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+/**
+ * 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
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;

package/RefSubject/definition.d.ts

@@ -0,0 +1,45 @@
+import { Ref } from "@fncts/io/Ref/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+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 declare const RefSubject: RefSubjectOps;
+export declare namespace RefSubject {
+    type Synchronized<R, E, A, B> = SynchronizedRefSubject<R, E, A, B>;
+}
+export declare 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> {
+    [Ref._RA]: () => R;
+    [Ref._RB]: () => R;
+    [Ref._EA]: () => never;
+    [Ref._EB]: () => never;
+    [Ref._A]: (_: A) => void;
+    [Ref._B]: () => B;
+    _R: (_: never) => R;
+    _E: (_: never) => E;
+    _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 declare function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B>;

package/RefSubject.d.ts

@@ -0,0 +1,3 @@
+export * from "./RefSubject/api.js";
+export * from "./RefSubject/Atomic.js";
+export * from "./RefSubject/definition.js";

package/RuntimeConfig.d.ts

@@ -2,34 +2,10 @@ import { CaseClass } from "@fncts/base/data/CaseClass";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { Logger } from "@fncts/io/Logger/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-export declare const RuntimeConfigFlag: {
-    readonly EnableCurrentFiber: symbol;
-    readonly LogRuntime: symbol;
-    readonly SuperviseOperations: symbol;
-    readonly TrackRuntimeMetrics: symbol;
-    readonly EnableFiberRoots: symbol;
-};
-export type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
 export declare 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 declare class RuntimeConfigFlags {
-    readonly flags: HashSet<RuntimeConfigFlag>;
-    constructor(flags: HashSet<RuntimeConfigFlag>);
-    add(flag: RuntimeConfigFlag): RuntimeConfigFlags;
-    isEnabled(flag: RuntimeConfigFlag): boolean;
-}
-/**
- * @tsplus static fncts.RuntimeConfigFlags empty
- * @tsplus location "@fncts/io/RuntimeConfig"
- */
-export declare const empty: RuntimeConfigFlags;

package/RuntimeFlag.d.ts

@@ -0,0 +1,10 @@
+export declare const enum RuntimeFlag {
+    Interruption = 1,
+    CurrentFiber = 2,
+    OpLog = 4,
+    OpSupervision = 8,
+    RuntimeMetrics = 16,
+    FiberRoots = 32,
+    WindDown = 64,
+    CooperativeYielding = 128
+}