@fncts/io 0.0.1

package/_src/Random/api.ts

@@ -0,0 +1,51 @@
+import type { ArrayInt } from "@fncts/base/util/rand";
+
+/**
+ * @tsplus static fncts.io.RandomOps nextDouble
+ */
+export const nextDouble = IO.randomWith((random) => random.nextDouble);
+
+/**
+ * @tsplus static fncts.io.RandomOps nextBoolean
+ */
+export const nextBoolean = IO.randomWith((random) => random.nextBoolean);
+
+/**
+ * @tsplus static fncts.io.RandomOps nextInt
+ */
+export const nextInt = IO.randomWith((random) => random.nextInt);
+
+/**
+ * @tsplus static fncts.io.RandomOps nextRange
+ */
+export function nextRange(low: number, high: number): IO<unknown, never, number> {
+  return IO.randomWith((random) => random.nextRange(low, high));
+}
+
+/**
+ * @tsplus static fncts.io.RandomOps nextIntBetween
+ */
+export function nextIntBetween(low: number, high: number): UIO<number> {
+  return IO.randomWith((random) => random.nextIntBetween(low, high));
+}
+
+/**
+ * @tsplus static fncts.io.RandomOps nextBigIntBetween
+ */
+export function nextBigIntBetween(low: bigint, high: bigint): UIO<bigint> {
+  return IO.randomWith((random) => random.nextBigIntBetween(low, high));
+}
+
+/**
+ * @tsplus static fncts.io.RandomOps nextArrayIntBetween
+ */
+export function nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt> {
+  return IO.randomWith((random) => random.nextArrayIntBetween(low, high));
+}
+
+/**
+ * @tsplus static fncts.io.RandomOps setSeed
+ */
+export function setSeed(seed: number): UIO<void> {
+  return IO.randomWith((random) => random.setSeed(seed));
+}

package/_src/Random/definition.ts

@@ -0,0 +1,21 @@
+import type { ArrayInt } from "@fncts/base/util/rand";
+
+/**
+ * @tsplus static fncts.io.RandomOps Tag
+ */
+export const RandomTag = Tag<Random>();
+
+/**
+ * @tsplus type fncts.io.Random
+ * @tsplus companion fncts.io.RandomOps
+ */
+export abstract class Random {
+  abstract readonly nextDouble: UIO<number>;
+  abstract readonly nextBoolean: UIO<boolean>;
+  abstract readonly nextInt: UIO<number>;
+  abstract nextRange(low: number, high: number): UIO<number>;
+  abstract nextIntBetween(low: number, high: number): UIO<number>;
+  abstract nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+  abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+  abstract setSeed(seed: number): UIO<void>;
+}

package/_src/Random/live.ts

@@ -0,0 +1,36 @@
+import type { ArrayInt } from "@fncts/base/util/rand";
+
+import { MersenneTwister, MutableRandom } from "@fncts/base/util/rand";
+
+export class LiveRandom implements Random {
+  private prng: MutableRandom;
+  constructor(seed: number) {
+    this.prng = new MutableRandom(new MersenneTwister(seed));
+  }
+
+  setSeed(seed: number): UIO<void> {
+    return IO.succeed(() => {
+      this.prng.setSeed(seed);
+    });
+  }
+  nextDouble  = IO.succeed(() => this.prng.nextDouble());
+  nextInt     = IO.succeed(() => this.prng.nextInt());
+  nextBoolean = this.nextDouble.flatMap((n) => IO.succeedNow(n > 0.5));
+  nextRange(low: number, high: number): UIO<number> {
+    return this.nextDouble.flatMap((n) => IO.succeedNow((high - low) * n + low));
+  }
+  nextIntBetween(low: number, high: number): UIO<number> {
+    return IO.succeed(this.prng.nextInt(low, high));
+  }
+  nextBigIntBetween(low: bigint, high: bigint): UIO<bigint> {
+    return IO.succeed(this.prng.nextBigInt(low, high));
+  }
+  nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt> {
+    return IO.succeed(this.prng.nextArrayInt(low, high));
+  }
+}
+
+/**
+ * @tsplus static fncts.io.RandomOps Live
+ */
+export const live: Random = new LiveRandom((Math.random() * 4294967296) >>> 0);

package/_src/Random.ts

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

package/_src/Ref/Atomic/Atomic.ts

@@ -0,0 +1,56 @@
+import type { PRef } from "../definition.js";
+
+import { RefInternal } from "../definition.js";
+import { Derived } from "../Derived.js";
+import { DerivedAll } from "../DerivedAll.js";
+
+/**
+ * @tsplus type fncts.io.Ref.Atomic
+ */
+export class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A> {
+  readonly _tag = "Atomic";
+
+  constructor(private value: A) {
+    super();
+    this.match    = this.match.bind(this);
+    this.matchAll = this.matchAll.bind(this);
+    this.set      = this.set.bind(this);
+  }
+
+  match<EC, ED, C, D>(
+    _ea: (_: never) => EC,
+    _eb: (_: never) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: A) => Either<ED, D>,
+  ): PRef<unknown, unknown, EC, ED, C, D> {
+    return new Derived<EC, ED, C, D>((f) => f(this, bd, ca));
+  }
+
+  matchAll<EC, ED, C, D>(
+    _ea: (_: never) => EC,
+    _eb: (_: never) => ED,
+    _ec: (_: never) => EC,
+    ca: (_: C) => (_: A) => Either<EC, A>,
+    bd: (_: A) => Either<ED, D>,
+  ): PRef<unknown, unknown, EC, ED, C, D> {
+    return new DerivedAll<EC, ED, C, D>((f) => f(this, bd, ca));
+  }
+
+  get unsafeGet(): A {
+    return this.value;
+  }
+
+  unsafeSet(a: A): void {
+    this.value = a;
+  }
+
+  get get(): UIO<A> {
+    return IO.succeed(this.value);
+  }
+
+  set(a: A): UIO<void> {
+    return IO.succeed(() => {
+      this.value = a;
+    });
+  }
+}

package/_src/Ref/Atomic/api.ts

@@ -0,0 +1,120 @@
+import type { Atomic } from "./Atomic.js";
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndSet
+ */
+export function getAndSet<A>(self: Atomic<A>, a: A): UIO<A> {
+  return IO.succeed(() => {
+    const v = self.unsafeGet;
+    self.unsafeSet(a);
+    return v;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
+ */
+export function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A) {
+  return IO.succeed(() => {
+    const v = self.unsafeGet;
+    self.unsafeSet(f(v));
+    return v;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
+ */
+export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+  return IO.succeed(() => {
+    const v = self.unsafeGet;
+    const o = f(v);
+    if (o._tag === "Just") {
+      self.unsafeSet(o.value);
+    }
+    return v;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic modify
+ */
+export function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A]) {
+  return IO.succeed(() => {
+    const v = self.unsafeGet;
+    const o = f(v);
+    self.unsafeSet(o[1]);
+    return o[0];
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic modifyJust
+ */
+export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>) {
+  return IO.succeed(() => {
+    const v = self.unsafeGet;
+    const o = f(v);
+
+    if (o._tag === "Just") {
+      self.unsafeSet(o.value[1]);
+      return o.value[0];
+    }
+
+    return def;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic update
+ */
+export function update<A>(self: Atomic<A>, f: (a: A) => A) {
+  return IO.succeed(() => {
+    self.unsafeSet(f(self.unsafeGet));
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
+ */
+export function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A) {
+  return IO.succeed(() => {
+    self.unsafeSet(f(self.unsafeGet));
+    return self.unsafeGet;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateJust
+ */
+export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+  return IO.succeed(() => {
+    const o = f(self.unsafeGet);
+
+    if (o._tag === "Just") {
+      self.unsafeSet(o.value);
+    }
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
+ */
+export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
+  return IO.succeed(() => {
+    const o = f(self.unsafeGet);
+
+    if (o._tag === "Just") {
+      self.unsafeSet(o.value);
+    }
+
+    return self.unsafeGet;
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
+ */
+export function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A) {
+  return self.unsafeSet(f(self.unsafeGet));
+}

package/_src/Ref/Atomic.ts

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

package/_src/Ref/Derived.ts

@@ -0,0 +1,71 @@
+import type { Atomic } from "./Atomic/Atomic.js";
+import type { PRef } from "./definition.js";
+
+import { RefInternal } from "./definition.js";
+import { DerivedAll } from "./DerivedAll.js";
+
+export class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+  readonly _tag = "Derived";
+
+  constructor(
+    readonly use: <X>(
+      f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X,
+    ) => X,
+  ) {
+    super();
+    this.match    = this.match.bind(this);
+    this.matchAll = this.matchAll.bind(this);
+    this.set      = this.set.bind(this);
+  }
+
+  match<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<unknown, unknown, EC, ED, C, D> {
+    return this.use(
+      (value, getEither, setEither) =>
+        new Derived<EC, ED, C, D>((f) =>
+          f(
+            value,
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+          ),
+        ),
+    );
+  }
+
+  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<unknown, unknown, EC, ED, C, D> {
+    return this.use(
+      (value, getEither, setEither) =>
+        new DerivedAll<EC, ED, C, D>((f) =>
+          f(
+            value,
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) =>
+              getEither(s)
+                .match(
+                  (eb) => Either.left(ec(eb)),
+                  (b) => ca(c)(b),
+                )
+                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+          ),
+        ),
+    );
+  }
+
+  get get(): FIO<EB, B> {
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
+  }
+
+  set(a: A): FIO<EA, void> {
+    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (s) => value.set(s)));
+  }
+}

package/_src/Ref/DerivedAll.ts

@@ -0,0 +1,75 @@
+import type { Atomic } from "./Atomic/Atomic.js";
+import type { PRef } from "./definition.js";
+
+import { RefInternal } from "./definition.js";
+
+export class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+  readonly _tag = "DerivedAll";
+
+  constructor(
+    readonly use: <X>(
+      f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X,
+    ) => X,
+  ) {
+    super();
+    this.match    = this.match.bind(this);
+    this.matchAll = this.matchAll.bind(this);
+    this.set      = this.set.bind(this);
+  }
+
+  match<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<unknown, unknown, EC, ED, C, D> {
+    return this.use(
+      (value, getEither, setEither) =>
+        new DerivedAll((f) =>
+          f(
+            value,
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+          ),
+        ),
+    );
+  }
+
+  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<unknown, unknown, EC, ED, C, D> {
+    return this.use(
+      (value, getEither, setEither) =>
+        new DerivedAll((f) =>
+          f(
+            value,
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) =>
+              getEither(s)
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+          ),
+        ),
+    );
+  }
+
+  get get(): FIO<EB, B> {
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
+  }
+
+  set(a: A): FIO<EA, void> {
+    return this.use(
+      (value, _, setEither) =>
+        value.modify((s) =>
+          setEither(a)(s).match(
+            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+            (s) => [Either.right(undefined), s],
+          ),
+        ).absolve,
+    );
+  }
+}

package/_src/Ref/Synchronized/api.ts

@@ -0,0 +1,234 @@
+import type { PRef } from "../definition.js";
+
+import { identity, tuple } from "@fncts/base/data/function";
+
+import { concreteSynchronized } from "./definition.js";
+
+/**
+ * Maps and filters the `get` value of the `SRef` with the specified
+ * effectual partial function, returning a `SRef` with a `get` value that
+ * succeeds with the result of the partial function if it is defined or else
+ * fails with `None`.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized collectIO
+ */
+export function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  f: (b: B) => Maybe<IO<RC, EC, C>>,
+): PRef.Synchronized<RA, RB & RC, EA, Maybe<EB | EC>, A, C> {
+  return ref.matchIO(
+    identity,
+    (eb) => Just<EB | EC>(eb),
+    IO.succeedNow,
+    (b) =>
+      f(b)
+        .map((a) => a.asJustError)
+        .getOrElse(IO.failNow(Nothing())),
+  );
+}
+
+/**
+ * Transforms the `set` value of the `SRef` with the specified effectual
+ * function.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized contramapIO
+ */
+export function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+): PRef.Synchronized<RA & RC, RB, EC | EA, EB, C, B> {
+  return ref.dimapIO(f, IO.succeedNow);
+}
+
+/**
+ * Transforms both the `set` and `get` values of the `Synchronized` with the
+ * specified effectual functions.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized dimapIO
+ */
+export function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+  g: (b: B) => IO<RD, ED, D>,
+): PRef.Synchronized<RA & RC, RB & RD, EA | EC, EB | ED, C, D> {
+  return ref.matchIO(
+    (ea: EA | EC) => ea,
+    (eb: EB | ED) => eb,
+    f,
+    g,
+  );
+}
+
+/**
+ * Filters the `set` value of the `SRef` with the specified effectual
+ * predicate, returning a `SRef` with a `set` value that succeeds if the
+ * predicate is satisfied or else fails with `None`.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized filterInputIO
+ */
+export function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  f: (a: A1) => IO<RC, EC, boolean>,
+): PRef.Synchronized<RA & RC, RB, Maybe<EC | EA>, EB, A1, B> {
+  return ref.matchIO(
+    (ea) => Just(ea),
+    identity,
+    (a) => f(a).asJustError.ifIO(IO.failNow(Nothing()), IO.succeedNow(a)),
+    IO.succeedNow,
+  );
+}
+
+/**
+ * Filters the `get` value of the `SRef` with the specified effectual predicate,
+ * returning a `SRef` with a `get` value that succeeds if the predicate is
+ * satisfied or else fails with `None`.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized filterOutputIO
+ */
+export function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  f: (b: B) => IO<RC, EC, boolean>,
+): PRef.Synchronized<RA, RB & RC, EA, Maybe<EC | EB>, A, B> {
+  return ref.matchIO(identity, Maybe.just, IO.succeedNow, (b) =>
+    f(b).asJustError.ifIO(IO.succeedNow(b), IO.failNow(Nothing())),
+  );
+}
+
+/**
+ * Atomically modifies the `Synchronized` with the specified function, returning the
+ * value immediately before modification.
+ */
+export function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => IO<R1, E1, A>,
+): IO<RA & RB & R1, EA | EB | E1, A> {
+  return ref.modifyIO((a) => f(a).map((r) => [a, r]));
+}
+
+/**
+ * Atomically modifies the `SRef` with the specified function, returning the
+ * value immediately before modification.
+ */
+export function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<IO<R1, E1, A>>,
+): IO<RA & RB & R1, EA | EB | E1, A> {
+  return ref.modifyIO((a) =>
+    f(a)
+      .getOrElse(IO.succeedNow(a))
+      .map((r) => [a, r]),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized matchIO
+ */
+export function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
+  self: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  ea: (_: EA) => EC,
+  eb: (_: EB) => ED,
+  ca: (_: C) => IO<RC, EC, A>,
+  bd: (_: B) => IO<RD, ED, D>,
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA & RC, RB & RD, EC, ED, C, D> {
+  return self.matchIO(ea, eb, ca, bd);
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized matchAllIO
+ */
+export function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
+  self: PRef.Synchronized<RA, RB, EA, EB, A, B>,
+  ea: (_: EA) => EC,
+  eb: (_: EB) => ED,
+  ec: (_: EB) => EC,
+  ca: (_: C) => (_: B) => IO<RC, EC, A>,
+  bd: (_: B) => IO<RD, ED, D>,
+  __tsplusTrace?: string,
+): PRef.Synchronized<RA & RB & RC, RB & RD, EC, ED, C, D> {
+  return self.matchAllIO(ea, eb, ec, ca, bd);
+}
+
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized modifyIO
+ */
+export function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(
+  self: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => IO<R1, E1, readonly [B, A]>,
+  __tsplusTrace?: string,
+): IO<RA & RB & R1, EA | EB | E1, B> {
+  concreteSynchronized(self);
+  return self.withPermit(self.unsafeGet.flatMap(f).flatMap(([b, a]) => self.unsafeSet(a).as(b)));
+}
+
+/**
+ * Atomically modifies the `Synchronized` with the specified function, which computes
+ * a return value for the modification if the function is defined in the current value
+ * otherwise it returns a default value.
+ * This is a more powerful version of `updateJust`.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized modifyJustIO
+ */
+export function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  def: B,
+  f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>,
+): IO<RA & RB & R1, EA | EB | E1, B> {
+  return ref.modifyIO((a) => f(a).getOrElse(IO.succeedNow(tuple(def, a))));
+}
+
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized updateAndGetIO
+ */
+export function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => IO<R1, E1, A>,
+): IO<RA & RB & R1, E1 | EA | EB, void> {
+  return ref.modifyIO((a) => f(a).map((r) => [r, r])).asUnit;
+}
+
+/**
+ * Atomically modifies the `Synchronized` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized updateIO
+ */
+export function updateIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => IO<R1, E1, A>,
+): IO<RA & RB & R1, E1 | EA | EB, void> {
+  return ref.modifyIO((a) => f(a).map((r) => [undefined, r]));
+}
+
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGetIO
+ */
+export function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<IO<R1, E1, A>>,
+): IO<RA & RB & R1, E1 | EA | EB, A> {
+  return ref.modifyIO((a) =>
+    f(a)
+      .getOrElse(IO.succeedNow(a))
+      .map((r) => [r, r]),
+  );
+}
+
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJustIO
+ */
+export function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(
+  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<IO<R1, E1, A>>,
+): IO<RA & RB & R1, E1 | EA | EB, void> {
+  return ref.modifyIO((a) =>
+    f(a)
+      .getOrElse(IO.succeedNow(a))
+      .map((r) => [undefined, r]),
+  );
+}

package/_src/Ref/Synchronized/constructors.ts

@@ -0,0 +1,12 @@
+import { PSynchronizedInternal } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps make
+ */
+export function makeSynchronized<A>(a: Lazy<A>): UIO<Ref.Synchronized<A>> {
+  return IO.gen(function* (_) {
+    const ref       = yield* _(Ref.make(a));
+    const semaphore = yield* _(TSemaphore.make(1).commit);
+    return new PSynchronizedInternal(new Set([semaphore]), ref.get, (a) => ref.set(a));
+  });
+}