@fncts/io 0.0.21 → 0.0.23

package/_src/Ref/definition.ts

@@ -1,105 +1,148 @@
 import type { Atomic as Atomic_ } from "./Atomic.js";
-import type { Synchronized as Synchronized_ } from "./Synchronized.js";
+import type * as Synchro from "./Synchronized/definition.js";
+
+export const RefVariance = Symbol.for("fncts.io.Ref.Variance");
+export type RefVariance = typeof RefVariance;
 
 export const RefTypeId = Symbol.for("fncts.io.Ref");
 export type RefTypeId = typeof RefTypeId;
 
+/**
+ * @tsplus type fncts.io.Ref
+ */
+export interface PRef<RA, RB, EA, EB, A, B> {
+  readonly [RefTypeId]: RefTypeId;
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+}
+
+export type Ref<A> = PRef<never, never, never, never, A, A>;
+export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
+
+export declare namespace PRef {
+  export type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
+}
+
+export declare namespace ERef {
+  export type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
+}
+
 export declare namespace Ref {
   export type Atomic<A> = Atomic_<A>;
-  export type Synchronized<A> = Synchronized_<A>;
+  export type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
 }
 
 /**
- * @tsplus type fncts.io.Ref
- * @tsplus companion fncts.io.RefOps
+ * @tsplus type fncts.io.RefOps
  */
-export abstract class Ref<A> {
-  readonly _typeId: RefTypeId = RefTypeId;
-  declare _A: (_: A) => A;
+export interface RefOps {}
+
+export const Ref: RefOps = {};
+
+export interface ReadableRef<RB, EB, B> {
+  readonly [RefVariance]: {
+    readonly _RB: (_: never) => RB;
+    readonly _EB: (_: never) => EB;
+    readonly _B: (_: never) => B;
+  };
+  readonly get: IO<RB, EB, B>;
+}
+
+export interface WritableRef<RA, EA, A> {
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _EA: (_: never) => EA;
+    readonly _A: (_: A) => void;
+  };
+  set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+}
+
+export interface ModifiableRef<RA, RB, EA, EB, A, B> {
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+  modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
+}
+
+export 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 = RefTypeId;
+  declare [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => 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
+   * 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.
+   */
+  abstract match<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<RA, RB, EC, ED, C, D>;
+
+  /**
+   * Folds over the error and value types ofthe `Ref`, allowing access to
+   * the state in transforming the `set` value. This is a more powerful version
+   * of `match` but requires unifying the error types.
+   */
+  abstract matchAll<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ec: (_: EB) => EC,
+    ca: (_: C) => (_: B) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<RA | RB, RB, EC, ED, C, D>;
+
   /**
    * Reads the value from the `Ref`.
    */
-  abstract get: UIO<A>;
+  abstract get get(): IO<RB, EB, B>;
+
   /**
    * Writes a new value to the `Ref`, with a guarantee of immediate
    * consistency (at some cost to performance).
    */
-  abstract set(a: A, __tsplusTrace?: string): UIO<void>;
+  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<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
-  /**
-   * Atomically writes the specified value to the `Ref`, returning the value
-   * immediately before modification.
-   */
-  getAndSet(a: A, __tsplusTrace?: string): UIO<A> {
-    return this.modify((v) => [v, a]);
-  }
-  /**
-   * Atomically modifies the `Ref` with the specified function, returning the
-   * value immediately before modification.
-   */
-  getAndUpdate(f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
-    return this.modify((v) => [v, f(v)]);
-  }
-  /**
-   * 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.
-   */
-  getAndUpdateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
-    return this.modify((v) => {
-      const result = f(v).getOrElse(v);
-      return [v, result];
-    });
-  }
-  /**
-   * 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`.
-   */
-  modifyJust<B>(orElse: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): UIO<B> {
-    return this.modify((v) => f(v).getOrElse([orElse, v]));
-  }
-  /**
-   * Atomically modifies the `Ref` with the specified function.
-   */
-  update(f: (a: A) => A, __tsplusTrace?: string): UIO<void> {
-    return this.modify((v) => [undefined, f(v)]);
-  }
-  /**
-   * Atomically modifies the `Ref` with the specified function and returns the
-   * updated value.
-   */
-  updateAndGet(f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
-    return this.modify((v) => {
-      const result = f(v);
-      return [result, result];
-    });
-  }
-  /**
-   * Atomically modifies the `Ref` with the specified partial function. If the
-   * function is undefined on the current value it doesn't change it.
-   */
-  updateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<void> {
-    return this.modify((v) => {
-      const result = f(v).getOrElse(v);
-      return [undefined, result];
-    });
-  }
-  /**
-   * 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.
-   */
-  updateJustAndGet(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
-    return this.modify((v) => {
-      const result = f(v).getOrElse(v);
-      return [result, result];
-    });
-  }
+  abstract modify<C>(f: (a: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
+}
+
+/**
+ * @tsplus macro remove
+ */
+export 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/_src/Ref.ts

@@ -1,6 +1,15 @@
 // codegen:start { preset: barrel, include: Ref/*.ts }
+export * from "./Ref/api.js";
 export * from "./Ref/Atomic.js";
 export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
+export * from "./Ref/Derived.js";
+export * from "./Ref/DerivedAll.js";
 export * from "./Ref/Synchronized.js";
 // codegen:end
+
+// codegen:start { preset: barrel, include: Ref/Synchronized/*.ts }
+export * from "./Ref/Synchronized/api.js";
+export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/Synchronized/definition.js";
+// codegen:end

package/_src/RefSubject/Atomic.ts

@@ -0,0 +1,120 @@
+import type { Emitter } from "@fncts/io/Push";
+
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { Hold, Push } from "@fncts/io/Push";
+import { Atomic } from "@fncts/io/Ref";
+import { RefSubjectInternal } from "@fncts/io/RefSubject";
+
+export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
+  readonly stream   = new Hold<never, E, A>(Push.never);
+  readonly maybeRef = new Atomic(this.stream.value);
+  readonly ref      = new AtomicEmitRef(
+    new AtomicDimapRef(
+      this.maybeRef,
+      (v) => v.getOrElse(this.initial),
+      (a) => Just(a),
+    ),
+    this.stream,
+  );
+
+  constructor(readonly initial: A) {
+    super();
+    this.stream.value.set(Just(initial));
+  }
+
+  get get() {
+    return this.ref.get;
+  }
+
+  set(value: A, __tsplusTrace?: string) {
+    return this.ref.set(value);
+  }
+
+  modify<E, A, B>(
+    this: AtomicRefSubject<E, A>,
+    f: (a: A) => readonly [B, A],
+    __tsplusTrace?: string,
+  ): IO<never, never, B> {
+    return this.ref.modify(f);
+  }
+
+  run<R>(emitter: Emitter<R, E, A>): IO<Scope | R, never, unknown> {
+    return this.stream.run(emitter);
+  }
+
+  emit(value: A): IO<never, never, void> {
+    return this.stream.emit(value);
+  }
+
+  failCause(cause: Cause<E>): IO<never, never, void> {
+    return this.stream.failCause(cause);
+  }
+
+  end: IO<never, never, void> = this.stream.end;
+
+  unsafeEmit(value: A): void {
+    return this.stream.emit(value).unsafeRunAsync();
+  }
+
+  unsafeFailCause(cause: Cause<E>): void {
+    return this.stream.failCause(cause).unsafeRunAsync();
+  }
+
+  unsafeEnd(): void {
+    return this.stream.end.unsafeRunAsync();
+  }
+}
+
+class AtomicDimapRef<A, B> extends Atomic<B> {
+  constructor(readonly ref: Atomic<A>, readonly f: (a: A) => B, readonly g: (b: B) => A) {
+    const value = new (class extends AtomicReference<B> {
+      constructor(readonly ref: AtomicReference<A>, readonly f: (a: A) => B, readonly g: (b: B) => A) {
+        super(f(ref.initial));
+      }
+
+      get get() {
+        return this.f(this.ref.get);
+      }
+
+      set(value: B) {
+        this.ref.set(this.g(value));
+      }
+
+      compareAndSet(old: B, value: B): boolean {
+        return this.ref.compareAndSet(this.g(old), this.g(value));
+      }
+
+      getAndSet(value: B): B {
+        return this.f(this.ref.getAndSet(this.g(value)));
+      }
+    })(ref.value, f, g);
+    super(value);
+  }
+}
+
+class AtomicEmitRef<E, A> extends Atomic<A> {
+  constructor(readonly ref: Atomic<A>, readonly emitter: Emitter<never, E, A>) {
+    super(ref.value);
+  }
+
+  get get() {
+    return this.ref.get;
+  }
+
+  get unsafeGet(): A {
+    return this.ref.unsafeGet;
+  }
+
+  unsafeSet(value: A) {
+    this.ref.unsafeSet(value);
+    this.emitter.emit(value).unsafeRunAsync();
+  }
+
+  set(value: A, __tsplusTrace?: string) {
+    return this.ref.set(value) < this.emitter.emit(value);
+  }
+
+  modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+    return this.ref.modify(f) < this.ref.get.flatMap((value) => this.emitter.emit(value));
+  }
+}

package/_src/RefSubject/Synchronized/api.ts

@@ -0,0 +1,14 @@
+import { concrete, RefSubject } from "@fncts/io/RefSubject";
+import { SynchronizedRefSubjectInternal } from "@fncts/io/RefSubject/Synchronized/definition";
+
+/**
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps make
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps __call
+ */
+export function make<A>(initial: Lazy<A>): UIO<RefSubject.Synchronized<never, never, A, A>> {
+  return Do((Δ) => {
+    const ref       = Δ(RefSubject.make(initial));
+    const semaphore = Δ(TSemaphore(1).commit);
+    return new SynchronizedRefSubjectInternal(semaphore, (concrete(ref), ref));
+  });
+}

package/_src/RefSubject/Synchronized/definition.ts

@@ -0,0 +1,72 @@
+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 const SynchronizedRefSubjectTypeId = Symbol.for("fncts.io.Push.SynchronizedRefSubject");
+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
+ */
+export const Synchronized: SynchronizedRefSubjectOps = {};
+
+export class SynchronizedRefSubjectInternal<R, E, A, B>
+  extends RefSubjectInternal<R, E, A, B>
+  implements SynchronizedRefSubject<R, E, A, B>
+{
+  readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId = SynchronizedRefSubjectTypeId;
+  constructor(readonly semaphore: TSemaphore, readonly ref: RefSubjectInternal<R, E, A, B>) {
+    super();
+  }
+
+  get get(): IO<R, never, B> {
+    return this.withPermit(this.ref.get);
+  }
+
+  set(a: A, __tsplusTrace?: string | undefined): IO<R, never, void> {
+    return this.withPermit(this.ref.set(a));
+  }
+
+  run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void> {
+    return this.ref.run(emitter);
+  }
+
+  modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<R, never, C> {
+    return this.modifyIO((a) => IO.succeedNow(f(a)));
+  }
+
+  modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<R | R1, E1, C> {
+    return this.withPermit(this.ref.get.flatMap(f).flatMap(([b, a]) => this.ref.set(a).as(b)));
+  }
+
+  emit(value: A): IO<R, never, void> {
+    return this.withPermit(this.ref.emit(value));
+  }
+
+  failCause(cause: Cause<E>): IO<R, never, void> {
+    return this.withPermit(this.ref.failCause(cause));
+  }
+
+  end: IO<R, never, void> = this.withPermit(this.ref.end);
+
+  withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+    return this.semaphore.withPermit(io);
+  }
+}

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);
+    });
+  };
+}