@fncts/io 0.0.20 → 0.0.21

package/_src/TRef/api.ts

@@ -45,290 +45,288 @@ export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>, __tsplusTrace?: stri
  * Updates the value of the variable, returning a function of the specified
  * value.
  *
- * @tsplus fluent fncts.io.TRef modify
+ * @tsplus pipeable fncts.io.TRef modify
  */
-export function modify_<E, A, B>(
-  self: TRef<E, E, A, A>,
-  f: (a: A) => readonly [B, A],
-  __tsplusTrace?: string,
-): STM<never, E, B> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry                = getOrMakeEntry(self, journal);
-        const oldValue             = entry.use((_) => _.unsafeGet<A>());
-        const [retValue, newValue] = f(oldValue);
-        entry.use((_) => _.unsafeSet(newValue));
-        return retValue;
-      });
-    }
-    case "Derived": {
-      return self.use((getEither, setEither, value, _atomic) =>
-        modify_(value, (s) =>
-          getEither(s).match(
-            (e) => [Either.left<E, B>(e), s],
-            (a1) => {
-              const [b, a2] = f(a1);
-              return setEither(a2).match(
-                (e) => [Either.left(e), s],
-                (s) => [Either.right(b), s],
-              );
-            },
+export function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, B> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry                = getOrMakeEntry(self, journal);
+          const oldValue             = entry.use((_) => _.unsafeGet<A>());
+          const [retValue, newValue] = f(oldValue);
+          entry.use((_) => _.unsafeSet(newValue));
+          return retValue;
+        });
+      }
+      case "Derived": {
+        return self.use((getEither, setEither, value, _atomic) =>
+          value.modify((s) =>
+            getEither(s).match(
+              (e) => [Either.left<E, B>(e), s],
+              (a1) => {
+                const [b, a2] = f(a1);
+                return setEither(a2).match(
+                  (e) => [Either.left(e), s],
+                  (s) => [Either.right(b), s],
+                );
+              },
+            ),
           ),
-        ),
-      ).absolve;
-    }
-    case "DerivedAll": {
-      return self.use((getEither, setEither, value, atomic) =>
-        modify_(value, (s) =>
-          getEither(s).match(
-            (e) => [Either.left<E, B>(e), s],
-            (a1) => {
-              const [b, a2] = f(a1);
-              return setEither(a2)(s).match(
-                (e) => [Either.left(e), s],
-                (s) => [Either.right(b), s],
-              );
-            },
+        ).absolve;
+      }
+      case "DerivedAll": {
+        return self.use((getEither, setEither, value, atomic) =>
+          value.modify((s) =>
+            getEither(s).match(
+              (e) => [Either.left<E, B>(e), s],
+              (a1) => {
+                const [b, a2] = f(a1);
+                return setEither(a2)(s).match(
+                  (e) => [Either.left(e), s],
+                  (s) => [Either.right(b), s],
+                );
+              },
+            ),
           ),
-        ),
-      ).absolve;
+        ).absolve;
+      }
     }
-  }
+  };
 }
 
 /**
  * Sets the value of the `TRef`.
  *
- * @tsplus fluent fncts.io.TRef set
+ * @tsplus pipeable fncts.io.TRef set
  */
-export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A, __tsplusTrace?: string): STM<never, EA, void> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry = getOrMakeEntry(self, journal);
-        return entry.use((_) => _.unsafeSet(a));
-      });
-    }
-    case "Derived": {
-      return self.use((_getEither, setEither, value, _atomic) =>
-        setEither(a).match(STM.failNow, (s) => set_(value, s)),
-      );
-    }
-    case "DerivedAll": {
-      return self.use((_getEither, setEither, value, _atomic) =>
-        modify_(value, (s) =>
-          setEither(a)(s).match(
-            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-            (s) => [Either.right(undefined), s],
+export function set<A>(a: A, __tsplusTrace?: string) {
+  return <EA, EB, B>(self: TRef<EA, EB, A, B>): STM<never, EA, void> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry = getOrMakeEntry(self, journal);
+          return entry.use((_) => _.unsafeSet(a));
+        });
+      }
+      case "Derived": {
+        return self.use((_getEither, setEither, value, _atomic) =>
+          setEither(a).match(STM.failNow, (s) => value.set(s)),
+        );
+      }
+      case "DerivedAll": {
+        return self.use((_getEither, setEither, value, _atomic) =>
+          value.modify((s) =>
+            setEither(a)(s).match(
+              (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+              (s) => [Either.right(undefined), s],
+            ),
           ),
-        ),
-      ).absolve;
+        ).absolve;
+      }
     }
-  }
+  };
 }
 
 /**
  * Unsafely retrieves the value of the `TRef`.
  *
- * @tsplus fluent fncts.io.TRef unsafeGet
+ * @tsplus pipeable fncts.io.TRef unsafeGet
  */
-export function unsafeGet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, __tsplusTrace?: string): A {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic":
-      return getOrMakeEntry(self.atomic, journal).use((entry) => entry.unsafeGet<A>());
-    default:
-      return self
-        .use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal))
-        .use((entry) => entry.unsafeGet());
-  }
+export function unsafeGet(journal: Journal, __tsplusTrace?: string) {
+  return <EA, EB, A, B>(self: TRef<EA, EB, A, B>): A => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic":
+        return getOrMakeEntry(self.atomic, journal).use((entry) => entry.unsafeGet<A>());
+      default:
+        return self
+          .use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal))
+          .use((entry) => entry.unsafeGet());
+    }
+  };
 }
 
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
  *
- * @tsplus fluent fncts.io.TRef modifyJust
+ * @tsplus pipeable fncts.io.TRef modifyJust
  */
-export function modifyJust_<E, A, B>(
-  self: TRef<E, E, A, A>,
-  b: B,
-  f: (a: A) => Maybe<readonly [B, A]>,
-  __tsplusTrace?: string,
-): STM<never, E, B> {
-  return self.modify((a) => f(a).getOrElse([b, a]));
+export function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, B> => {
+    return self.modify((a) => f(a).getOrElse([b, a]));
+  };
 }
 
 /**
  * Sets the value of the `TRef` and returns the old value.
  *
- * @tsplus fluent fncts.io.TRef getAndSet
+ * @tsplus pipeable fncts.io.TRef getAndSet
  */
-export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A, __tsplusTrace?: string): STM<never, E, A> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry    = getOrMakeEntry(self, journal);
-        const oldValue = entry.use((entry) => entry.unsafeGet<A>());
-        entry.use((entry) => entry.unsafeSet(a));
-        return oldValue;
-      });
-    }
-    default: {
-      return modify_(self, (oldA) => [oldA, a]);
+export function getAndSet<A>(a: A, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, A> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry    = getOrMakeEntry(self, journal);
+          const oldValue = entry.use((entry) => entry.unsafeGet<A>());
+          entry.use((entry) => entry.unsafeSet(a));
+          return oldValue;
+        });
+      }
+      default: {
+        return self.modify((oldA) => [oldA, a]);
+      }
     }
-  }
+  };
 }
 
 /**
  * Updates the value of the variable and returns the old value.
  *
- * @tsplus fluent fncts.io.TRef getAndUpdate
+ * @tsplus pipeable fncts.io.TRef getAndUpdate
  */
-export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry    = getOrMakeEntry(self, journal);
-        const oldValue = entry.use((_) => _.unsafeGet<A>());
-        entry.use((_) => _.unsafeSet(f(oldValue)));
-        return oldValue;
-      });
-    }
-    default: {
-      return modify_(self, (_) => [_, f(_)]);
+export function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, A> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry    = getOrMakeEntry(self, journal);
+          const oldValue = entry.use((_) => _.unsafeGet<A>());
+          entry.use((_) => _.unsafeSet(f(oldValue)));
+          return oldValue;
+        });
+      }
+      default: {
+        return self.modify((_) => [_, f(_)]);
+      }
     }
-  }
+  };
 }
 
 /**
  * Updates some values of the variable but leaves others alone, returning the
  * old value.
  *
- * @tsplus fluent fncts.io.TRef getAndUpdateJust
+ * @tsplus pipeable fncts.io.TRef getAndUpdateJust
  */
-export function getAndUpdateJust_<E, A>(
-  self: TRef<E, E, A, A>,
-  f: (a: A) => Maybe<A>,
-  __tsplusTrace?: string,
-): STM<never, E, A> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry    = getOrMakeEntry(self, journal);
-        const oldValue = entry.use((_) => _.unsafeGet<A>());
-        const v        = f(oldValue);
-        if (v.isJust()) {
-          entry.use((_) => _.unsafeSet(v.value));
-        }
-        return oldValue;
-      });
-    }
-    default: {
-      return modify_(self, (a) =>
-        f(a).match(
-          () => [a, a],
-          (v) => [a, v],
-        ),
-      );
+export function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, A> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry    = getOrMakeEntry(self, journal);
+          const oldValue = entry.use((_) => _.unsafeGet<A>());
+          const v        = f(oldValue);
+          if (v.isJust()) {
+            entry.use((_) => _.unsafeSet(v.value));
+          }
+          return oldValue;
+        });
+      }
+      default: {
+        return self.modify((a) =>
+          f(a).match(
+            () => [a, a],
+            (v) => [a, v],
+          ),
+        );
+      }
     }
-  }
+  };
 }
 
 /**
  * Updates the value of the variable.
  *
- * @tsplus fluent fncts.io.TRef update
+ * @tsplus pipeable fncts.io.TRef update
  */
-export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, void> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry    = getOrMakeEntry(self, journal);
-        const newValue = f(entry.use((_) => _.unsafeGet<A>()));
-        entry.use((_) => _.unsafeSet(newValue));
-      });
+export function update<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, void> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry    = getOrMakeEntry(self, journal);
+          const newValue = f(entry.use((_) => _.unsafeGet<A>()));
+          entry.use((_) => _.unsafeSet(newValue));
+        });
+      }
+      default:
+        return self.modify((a) => [undefined, f(a)]);
     }
-    default:
-      return modify_(self, (a) => [undefined, f(a)]);
-  }
+  };
 }
 
 /**
  * Updates some values of the variable but leaves others alone.
  *
- * @tsplus fluent fncts.io.TRef updateJust
+ * @tsplus pipeable fncts.io.TRef updateJust
  */
-export function updateJust_<E, A>(
-  self: TRef<E, E, A, A>,
-  f: (a: A) => Maybe<A>,
-  __tsplusTrace?: string,
-): STM<never, E, void> {
-  return self.update((a) => f(a).getOrElse(a));
+export function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, void> => {
+    return self.update((a) => f(a).getOrElse(a));
+  };
 }
 
 /**
  * Updates the value of the variable and returns the new value.
  *
- * @tsplus fluent fncts.io.TRef updateAndGet
+ * @tsplus pipeable fncts.io.TRef updateAndGet
  */
-export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A> {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic": {
-      return new Effect((journal) => {
-        const entry    = getOrMakeEntry(self, journal);
-        const oldValue = entry.use((e) => e.unsafeGet<A>());
-        const newValue = f(oldValue);
-        entry.use((e) => e.unsafeSet(newValue));
-        return newValue;
-      });
-    }
-    default: {
-      return modify_(self, (a) => {
-        const newValue = f(a);
-        return [newValue, newValue];
-      });
+export function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, A> => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic": {
+        return new Effect((journal) => {
+          const entry    = getOrMakeEntry(self, journal);
+          const oldValue = entry.use((e) => e.unsafeGet<A>());
+          const newValue = f(oldValue);
+          entry.use((e) => e.unsafeSet(newValue));
+          return newValue;
+        });
+      }
+      default: {
+        return self.modify((a) => {
+          const newValue = f(a);
+          return [newValue, newValue];
+        });
+      }
     }
-  }
+  };
 }
 
 /**
  * Updates some values of the variable but leaves others alone.
  *
- * @tsplus fluent fncts.io.TRef updateJustAndGet
+ * @tsplus pipeable fncts.io.TRef updateJustAndGet
  */
-export function updateJustAndGet_<E, A>(
-  self: TRef<E, E, A, A>,
-  f: (a: A) => Maybe<A>,
-  __tsplusTrace?: string,
-): STM<never, E, A> {
-  return self.updateAndGet((a) => f(a).getOrElse(a));
+export function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return <E>(self: TRef<E, E, A, A>): STM<never, E, A> => {
+    return self.updateAndGet((a) => f(a).getOrElse(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.TRef unsafeSet
+ * @tsplus pipeable fncts.io.TRef unsafeSet
  */
-export function unsafeSet_<EA, EB, A, B>(
-  self: TRef<EA, EB, A, B>,
-  journal: Journal,
-  a: A,
-  __tsplusTrace?: string,
-): void {
-  concrete(self);
-  switch (self._tag) {
-    case "Atomic":
-      return getOrMakeEntry(self.atomic, journal).use((entry) => entry.unsafeSet(a));
-    default:
-      return self
-        .use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal))
-        .use((entry) => entry.unsafeSet(a));
-  }
+export function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string) {
+  return <EA, EB, B>(self: TRef<EA, EB, A, B>): void => {
+    concrete(self);
+    switch (self._tag) {
+      case "Atomic":
+        return getOrMakeEntry(self.atomic, journal).use((entry) => entry.unsafeSet(a));
+      default:
+        return self
+          .use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal))
+          .use((entry) => entry.unsafeSet(a));
+    }
+  };
 }

package/_src/TRef/definition.ts

@@ -2,7 +2,6 @@ import type { Todo } from "../STM/internal/Journal.js";
 import type { Versioned } from "../STM/internal/Versioned.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import type { TxnId } from "@fncts/io/TxnId";
-
 export const TRefTypeId = Symbol.for("fncts.io.TRef");
 export type TRefTypeId = typeof TRefTypeId;
 
@@ -44,14 +43,12 @@ export abstract class TRefInternal<EA, EB, A, B> implements TRef<EA, EB, A, B> {
   readonly _EB!: () => EB;
   readonly _A!: (_: A) => void;
   readonly _B!: () => B;
-
   abstract match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ca: (c: C) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
   ): TRef<EC, ED, C, D>;
-
   abstract matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
@@ -75,11 +72,9 @@ export class Atomic<A> extends TRefInternal<never, never, A, A> {
   readonly _typeId: TRefTypeId     = TRefTypeId;
   readonly _tag                    = "Atomic";
   readonly atomic: Atomic<unknown> = this as Atomic<unknown>;
-
   constructor(public versioned: Versioned<A>, readonly todo: AtomicReference<HashMap<TxnId, Todo>>) {
     super();
   }
-
   match<EC, ED, C, D>(
     _ea: (ea: never) => EC,
     _eb: (ea: never) => ED,
@@ -88,7 +83,6 @@ export class Atomic<A> extends TRefInternal<never, never, A, A> {
   ): TRef<EC, ED, C, D> {
     return new Derived((f) => f(bd, ca, this, this.atomic));
   }
-
   matchAll<EC, ED, C, D>(
     _ea: (ea: never) => EC,
     _eb: (ea: never) => ED,
@@ -103,7 +97,6 @@ export class Atomic<A> extends TRefInternal<never, never, A, A> {
 export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   readonly _typeId: TRefTypeId = TRefTypeId;
   readonly _tag                = "Derived";
-
   constructor(
     readonly use: <X>(
       f: <S>(
@@ -116,7 +109,6 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   ) {
     super();
   }
-
   match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
@@ -135,7 +127,6 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
-
   matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
@@ -163,7 +154,6 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   readonly _typeId: TRefTypeId = TRefTypeId;
   readonly _tag                = "DerivedAll";
-
   constructor(
     readonly use: <X>(
       f: <S>(
@@ -176,7 +166,6 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   ) {
     super();
   }
-
   match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
@@ -195,7 +184,6 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
-
   matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,

package/_src/TSemaphore/api.ts

@@ -10,17 +10,17 @@ export function acquire(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
 }
 
 /**
- * @tsplus fluent fncts.io.TSemaphore acquireN
+ * @tsplus pipeable fncts.io.TSemaphore acquireN
  */
-export function acquireN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
-  return new Effect((journal) => {
-    assert(n >= 0, "Negative permits given to TSemaphore#acquire");
-
-    const value = TSemaphore.reverseGet(self).unsafeGet(journal);
-
-    if (value < n) throw new RetryException();
-    else return TSemaphore.reverseGet(self).unsafeSet(journal, value - n);
-  });
+export function acquireN(n: number, __tsplusTrace?: string) {
+  return (self: TSemaphore): USTM<void> => {
+    return new Effect((journal) => {
+      assert(n >= 0, "Negative permits given to TSemaphore#acquireN");
+      const value = TSemaphore.reverseGet(self).unsafeGet(journal);
+      if (value < n) throw new RetryException();
+      else return TSemaphore.reverseGet(self).unsafeSet(journal, value - n);
+    });
+  };
 }
 
 /**
@@ -38,15 +38,16 @@ export function release(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
 }
 
 /**
- * @tsplus fluent fncts.io.TSemaphore releaseN
+ * @tsplus pipeable fncts.io.TSemaphore releaseN
  */
-export function releaseN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
-  return new Effect((journal) => {
-    assert(n >= 0, "Negative permits given to TSemaphore#releaseN");
-
-    const current = TSemaphore.reverseGet(self).unsafeGet(journal);
-    TSemaphore.reverseGet(self).unsafeSet(journal, current + n);
-  });
+export function releaseN(n: number, __tsplusTrace?: string) {
+  return (self: TSemaphore): USTM<void> => {
+    return new Effect((journal) => {
+      assert(n >= 0, "Negative permits given to TSemaphore#releaseN");
+      const current = TSemaphore.reverseGet(self).unsafeGet(journal);
+      TSemaphore.reverseGet(self).unsafeSet(journal, current + n);
+    });
+  };
 }
 
 /**

package/_src/TSemaphore/constructors.ts

@@ -6,6 +6,13 @@ export function make(permits: number, __tsplusTrace?: string): USTM<TSemaphore>
   return TRef.make(permits).map((ref) => TSemaphore.get(ref));
 }
 
+/**
+ * @tsplus static fncts.io.TSemaphoreOps makeCommit
+ */
+export function makeCommit(permits: number, __tsplusTrace?: string): UIO<TSemaphore> {
+  return TSemaphore(permits).commit;
+}
+
 /**
  * @tsplus static fncts.io.TSemaphoreOps unsafeMake
  */