@fncts/io 0.0.1

package/_src/Ref/Synchronized/definition.ts

@@ -0,0 +1,126 @@
+import type { PRef } from "../definition.js";
+
+import { RefInternal } from "../definition.js";
+
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ */
+export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {}
+
+/**
+ * @tsplus type fncts.io.Ref.SynchronizedOps
+ */
+export interface PSynchronizedOps {}
+
+/**
+ * @tsplus static fncts.io.RefOps Synchronized
+ */
+export const Synchronized: PSynchronizedOps = {};
+
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ */
+export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
+  readonly _tag = "Synchronized";
+  constructor(
+    readonly semaphores: Set<TSemaphore>,
+    readonly unsafeGet: IO<RB, EB, B>,
+    readonly unsafeSet: (a: A) => IO<RA, EA, void>,
+  ) {
+    super();
+  }
+
+  get get(): IO<RB, EB, B> {
+    if (this.semaphores.size === 1) {
+      return this.unsafeGet;
+    } else {
+      return this.withPermit(this.unsafeGet);
+    }
+  }
+
+  set(a: A, __tsplusTrace?: string): IO<RA, EA, void> {
+    return this.withPermit(this.unsafeSet(a));
+  }
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ec: (_: EB) => EC,
+    ca: (_: C) => (_: B) => IO<RC, EC, A>,
+    bd: (_: B) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RA & RC & RB, RB & RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphores,
+      this.get.matchIO((e) => IO.failNow(eb(e)), bd),
+      (c) =>
+        this.get.matchIO(
+          (e) => IO.failNow(ec(e)),
+          (b) => ca(c)(b).flatMap((a) => this.unsafeSet(a).mapError(ea)),
+        ),
+    );
+  }
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => IO<RC, EC, A>,
+    bd: (_: B) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RA & RC, RB & RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphores,
+      this.unsafeGet.matchIO((e) => IO.failNow(eb(e)), bd),
+      (c) => ca(c).flatMap((a) => this.unsafeSet(a).mapError(ea)),
+    );
+  }
+
+  match<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
+    return this.matchIO(
+      ea,
+      eb,
+      (c) => IO.fromEitherNow(ca(c)),
+      (b) => IO.fromEitherNow(bd(b)),
+    );
+  }
+
+  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>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
+    return this.matchAllIO(
+      ea,
+      eb,
+      ec,
+      (c) => (b) => IO.fromEitherNow(ca(c)(b)),
+      (b) => IO.fromEitherNow(bd(b)),
+    ) as PSynchronizedInternal<RA, RB, EC, ED, C, D>;
+  }
+
+  withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+    return IO.uninterruptibleMask(({ restore }) =>
+      restore(STM.foreach(this.semaphores, (s) => s.acquire).commit).apSecond(
+        restore(io).ensuring(STM.foreach(this.semaphores, (s) => s.release).commit),
+      ),
+    );
+  }
+}
+
+/**
+ * @tsplus macro remove
+ */
+export function concreteSynchronized<RA, RB, EA, EB, A, B>(
+  self: PSynchronized<RA, RB, EA, EB, A, B>,
+): asserts self is PSynchronizedInternal<RA, RB, EA, EB, A, B> {
+  //
+}

package/_src/Ref/api/collect.ts

@@ -0,0 +1,18 @@
+import type { PRef } from "../definition.js";
+
+import { identity } from "@fncts/base/data/function";
+
+/**
+ * Maps and filters the `get` value of the `Ref` with the specified partial
+ * function, returning a `Ref` 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 collect
+ * @tsplus fluent fncts.io.Ref.Synchronized collect
+ */
+export function collect_<RA, RB, EA, EB, A, B, C>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  pf: (_: B) => Maybe<C>,
+): PRef<RA, RB, EA, Maybe<EB>, A, C> {
+  return ref.match(identity, Maybe.just, Either.right, (b) => pf(b).toEither(Nothing()));
+}

package/_src/Ref/api/dimap.ts

@@ -0,0 +1,108 @@
+import type { PRef } from "../definition.js";
+
+/**
+ * Transforms the `set` value of the `Ref` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref contramap
+ * @tsplus fluent fncts.io.Ref.Synchronized contramap
+ */
+export function contramap_<RA, RB, EA, EB, B, A, C>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: C) => A,
+): PRef<RA, RB, EA, EB, C, B> {
+  return ref.contramapEither((c) => Either.right(f(c)));
+}
+
+/**
+ * Transforms the `set` value of the `Ref` with the specified fallible
+ * function.
+ *
+ * @tsplus fluent fncts.io.Ref contramapEither
+ * @tsplus fluent fncts.io.Ref.Synchronized contramapEither
+ */
+export function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: C) => Either<EC, A>,
+): PRef<RA, RB, EC | EA, EB, C, B> {
+  return ref.dimapEither(f, Either.right);
+}
+
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified functions.
+ *
+ * @tsplus fluent fncts.io.Ref dimap
+ * @tsplus fluent fncts.io.Ref.Synchronized dimap
+ */
+export function dimap_<RA, RB, EA, EB, A, B, C, D>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: C) => A,
+  g: (_: B) => D,
+): PRef<RA, RB, EA, EB, C, D> {
+  return ref.dimapEither(
+    (c) => Either.right(f(c)),
+    (b) => Either.right(g(b)),
+  );
+}
+
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified fallible functions.
+ *
+ * @tsplus fluent fncts.io.Ref dimapEither
+ * @tsplus fluent fncts.io.Ref.Synchronized dimapEither
+ */
+export function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: C) => Either<EC, A>,
+  g: (_: B) => Either<ED, D>,
+): PRef<RA, RB, EC | EA, ED | EB, C, D> {
+  return ref.match(
+    (ea: EA | EC) => ea,
+    (eb: EB | ED) => eb,
+    f,
+    g,
+  );
+}
+
+/**
+ * Transforms both the `set` and `get` errors of the `Ref` with the
+ * specified functions.
+ *
+ * @tsplus fluent fncts.io.Ref dimapError
+ * @tsplus fluent fncts.io.Ref.Synchronized dimapError
+ */
+export function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: EA) => EC,
+  g: (_: EB) => ED,
+): PRef<RA, RB, EC, ED, A, B> {
+  return ref.match(f, g, Either.right, Either.right);
+}
+
+/**
+ * Transforms the `get` value of the `Ref` with the specified fallible
+ * function.
+ *
+ * @tsplus fluent fncts.io.Ref mapEither
+ * @tsplus fluent fncts.io.Ref.Synchronized mapEither
+ */
+export function mapEither_<RA, RB, EA, EB, A, B, EC, C>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: B) => Either<EC, C>,
+): PRef<RA, RB, EA, EC | EB, A, C> {
+  return ref.dimapEither(Either.right, f);
+}
+
+/**
+ * Transforms the `get` value of the `Ref` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref map
+ * @tsplus fluent fncts.io.Ref.Synchronized map
+ */
+export function map_<RA, RB, EA, EB, A, B, C>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: B) => C,
+): PRef<RA, RB, EA, EB, A, C> {
+  return ref.mapEither((b) => Either.right(f(b)));
+}

package/_src/Ref/api/filter.ts

@@ -0,0 +1,33 @@
+import type { PRef } from "../definition.js";
+
+import { identity } from "@fncts/base/data/function";
+
+/**
+ * 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
+ */
+export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: A1) => boolean,
+): PRef<RA, RB, Maybe<EA>, EB, A1, B> {
+  return ref.match(Maybe.just, identity, (a) => (f(a) ? Either.right(a) : Either.left(Nothing())), Either.right);
+}
+
+/**
+ * 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
+ */
+export function filterOutput_<RA, RB, EA, EB, A, B>(
+  ref: PRef<RA, RB, EA, EB, A, B>,
+  f: (_: B) => boolean,
+): PRef<RA, RB, EA, Maybe<EB>, A, B> {
+  return ref.match(identity, Maybe.just, Either.right, (b) => (f(b) ? Either.right(b) : Either.left(Nothing())));
+}

package/_src/Ref/api/get.ts

@@ -0,0 +1,14 @@
+import type { PRef } from "../definition.js";
+
+import { concrete } from "../definition.js";
+
+/**
+ * Reads the value from the `Ref`.
+ *
+ * @tsplus getter fncts.io.Ref get
+ * @tsplus getter fncts.io.Ref.Synchronized get
+ */
+export function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>): IO<RA & RB, EA | EB, B> {
+  concrete(self);
+  return self.get as IO<RA & RB, EA | EB, B>;
+}

package/_src/Ref/api/match.ts

@@ -0,0 +1,24 @@
+import type { PRef } from "../definition.js";
+
+import { concrete } from "../definition.js";
+
+/**
+ * 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.
+ *
+ * @tsplus fluent fncts.io.Ref match
+ * @tsplus fluent fncts.io.Ref.Synchronized match
+ */
+export 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> {
+  concrete(ref);
+  return ref.match(ea, eb, ca, bd as any);
+}

package/_src/Ref/api/matchAll.ts

@@ -0,0 +1,23 @@
+import type { PRef } from "../definition.js";
+
+import { concrete } from "../definition.js";
+
+/**
+ * Folds over the error and value types of the `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.
+ *
+ * @tsplus fluent fncts.io.Ref matchAll
+ * @tsplus fluent fncts.io.Ref.Synchronized matchAll
+ */
+export 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> {
+  concrete(ref);
+  return ref.matchAll(ea, eb, ec, ca as any, bd as any);
+}

package/_src/Ref/api/modify.ts

@@ -0,0 +1,225 @@
+import type { PRef } from "../definition.js";
+
+import { tuple } from "@fncts/base/data/function";
+
+import { concrete } 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
+ */
+export function modify_<RA, RB, EA, EB, B, A>(
+  ref: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => readonly [B, A],
+): IO<RA & RB, EA | EB, B> {
+  concrete(ref);
+  switch (ref._tag) {
+    case "Atomic":
+      return ref.modify(f);
+    case "Derived":
+      return ref.use(
+        (value, getEither, setEither) =>
+          value.modify((s) =>
+            getEither(s).match(
+              (e) => tuple(Either.left(e), s),
+              (a1) => {
+                const [b, a2] = f(a1);
+                return setEither(a2).match(
+                  (e) => tuple(Either.left(e), s),
+                  (s) => tuple(Either.right<EA | EB, B>(b), s),
+                );
+              },
+            ),
+          ).absolve,
+      );
+    case "DerivedAll":
+      return ref.use(
+        (value, getEither, setEither) =>
+          value.modify((s) =>
+            getEither(s).match(
+              (e) => tuple(Either.left(e), s),
+              (a1) => {
+                const [b, a2] = f(a1);
+                return setEither(a2)(s).match(
+                  (e) => tuple(Either.left(e), s),
+                  (s) => tuple(Either.right<EA | EB, B>(b), s),
+                );
+              },
+            ),
+          ).absolve,
+      );
+    case "Synchronized":
+      return ref.modifyIO((a) => IO.succeedNow(f(a)));
+  }
+}
+
+/**
+ * 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
+ */
+export 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]>,
+): IO<RA & RB, EA | EB, B> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.modifyJust(def, f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).modify((a) => f(a).getOrElse(tuple(def, a)));
+  }
+}
+
+/**
+ * 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
+ */
+export function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A): IO<RA & RB, EA | EB, A> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.getAndSet(a);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).modify((a0) => tuple(a0, 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
+ */
+export function getAndUpdate_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => A,
+): IO<RA & RB, EA | EB, A> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.getAndUpdate(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).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 fluent fncts.io.Ref getAndUpdateJust
+ * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdateJust
+ */
+export function getAndUpdateJust_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<A>,
+): IO<RA & RB, EA | EB, A> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.getAndUpdateJust(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).modify((a0) => tuple(a0, f(a0).getOrElse(a0)));
+  }
+}
+
+/**
+ * Atomically modifies the `Ref` with the specified function.
+ *
+ * @tsplus fluent fncts.io.Ref update
+ * @tsplus fluent fncts.io.Ref.Synchronized update
+ */
+export function update_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => A,
+): IO<RA & RB, EA | EB, void> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.update(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).modify((a0) => tuple(undefined, f(a0)));
+  }
+}
+
+/**
+ * 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
+ */
+export function updateAndGet_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => A,
+): IO<RA & RB, EA | EB, A> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.updateAndGet(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).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 fluent fncts.io.Ref updateJust
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJust
+ */
+export function updateJust_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<A>,
+): IO<RA & RB, EA | EB, void> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.updateJust(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).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 fluent fncts.io.Ref updateJustAndGet
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGet
+ */
+export function updateJustAndGet_<RA, RB, EA, EB, A>(
+  self: PRef<RA, RB, EA, EB, A, A>,
+  f: (a: A) => Maybe<A>,
+): IO<RA & RB, EA | EB, A> {
+  concrete(self);
+  switch (self._tag) {
+    case "Atomic":
+      return self.updateJustAndGet(f);
+    default:
+      return (self as PRef<RA, RB, EA, EB, A, A>).modify((a0) => {
+        const r = f(a0).getOrElse(a0);
+        return tuple(r, r);
+      });
+  }
+}

package/_src/Ref/api/set.ts

@@ -0,0 +1,15 @@
+import type { PRef } from "../definition.js";
+
+import { concrete } 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
+ */
+export function set_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, a: A): IO<RA & RB, EA | EB, void> {
+  concrete(self);
+  return self.set(a);
+}

package/_src/Ref/api.ts

@@ -0,0 +1,39 @@
+import type { PRef } from "./definition.js";
+
+import { identity } from "@fncts/base/data/function";
+
+// codegen:start { preset: barrel, include: api/*.ts }
+export * from "./api/collect.js";
+export * from "./api/dimap.js";
+export * from "./api/filter.js";
+export * from "./api/get.js";
+export * from "./api/match.js";
+export * from "./api/matchAll.js";
+export * from "./api/modify.js";
+export * from "./api/set.js";
+// codegen:end
+
+/**
+ * Returns a read only view of the `Ref`.
+ *
+ * @tsplus getter fncts.io.Ref readOnly
+ * @tsplus getter fncts.io.Ref.Synchronized readOnly
+ */
+export function readOnly<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>): PRef<RA, RB, EA, EB, never, B> {
+  return ref;
+}
+
+/**
+ * Returns a write only view of the `Ref`.
+ *
+ * @tsplus getter fncts.io.Ref writeOnly
+ * @tsplus getter fncts.io.Ref.Synchronized writeOnly
+ */
+export function writeOnly<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>): PRef<RA, RB, EA, void, A, never> {
+  return ref.match(
+    identity,
+    () => undefined,
+    Either.right,
+    () => Either.left(undefined),
+  );
+}

package/_src/Ref/constructors.ts

@@ -0,0 +1,15 @@
+import { Atomic } from "./Atomic.js";
+
+/**
+ * @tsplus static fncts.io.RefOps make
+ */
+export function make<A>(a: Lazy<A>): UIO<Ref<A>> {
+  return IO.succeed(unsafeMake(a()));
+}
+
+/**
+ * @tsplus static fncts.io.RefOps unsafeMake
+ */
+export function unsafeMake<A>(a: A): Ref.Atomic<A> {
+  return new Atomic(a);
+}