@fncts/io 0.0.48 → 0.0.50

package/_src/RefSubject/api.ts

@@ -1,253 +0,0 @@
-import { tuple } from "@fncts/base/data/function";
-import { Sink } 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: Sink<R1, E, D>): IO<R | R1, never, void> {
-    return this.ref.run(
-      Sink(
-        (value) => emitter.event(this.g(value)),
-        (cause) => emitter.error(cause),
-      ),
-    );
-  }
-
-  event(value: C): IO<R, never, void> {
-    return this.ref.event(this.f(value));
-  }
-
-  error(cause: Cause<E>): IO<R, never, void> {
-    return this.ref.error(cause);
-  }
-
-  get unsafeGet(): D {
-    return this.g(this.ref.unsafeGet);
-  }
-}
-
-/**
- * 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);
-    });
-  };
-}
-
-/**
- * @tsplus getter fncts.io.Push.RefSubject unsafeGet
- */
-export function unsafeGet<R, E, A, B>(self: RefSubject<R, E, A, B>): B {
-  concrete(self);
-  return self.unsafeGet;
-}

package/_src/RefSubject/definition.ts

@@ -1,70 +0,0 @@
-import type { Sink } 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";
-
-import { PushTypeId } from "../Push.js";
-import { PushVariance } from "../Push.js";
-import { RefVariance } from "../Ref.js";
-
-/**
- * @tsplus type fncts.io.Push.RefSubject
- */
-export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Sink<R, E, A> {}
-
-/**
- * @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>,
-    Sink<R, E, A>
-{
-  readonly [PushTypeId]: PushTypeId = PushTypeId;
-  declare [RefVariance]: {
-    readonly _RA: (_: never) => R;
-    readonly _RB: (_: never) => R;
-    readonly _EA: (_: never) => never;
-    readonly _EB: (_: never) => never;
-    readonly _A: (_: A) => void;
-    readonly _B: (_: never) => B;
-  };
-  declare [PushVariance]: {
-    readonly _R: (_: never) => R;
-    readonly _E: (_: never) => E;
-    readonly _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: Sink<R1, E, B>): IO<R | R1, never, void>;
-
-  abstract error(cause: Cause<E>): IO<R, never, void>;
-
-  abstract event(value: A): IO<R, never, void>;
-
-  abstract get unsafeGet(): B;
-}
-
-/**
- * @tsplus static fncts.io.Push.RefSubjectOps concrete
- * @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

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