@fncts/io 0.0.19 → 0.0.21

package/_src/TFuture/api.ts

@@ -1,23 +1,27 @@
 /**
- * @tsplus fluent fncts.io.TFuture done
+ * @tsplus pipeable fncts.io.TFuture done
  */
-export function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>, __tsplusTrace?: string): USTM<boolean> {
-  return TFuture.reverseGet(self).get.flatMap((mea) =>
-    mea.match(
-      () =>
-        TFuture.reverseGet(self)
-          .set(Just(v))
-          .flatMap(() => STM.succeedNow(true)),
-      () => STM.succeedNow(false),
-    ),
-  );
+export function done<E, A>(v: Either<E, A>, __tsplusTrace?: string) {
+  return (self: TFuture<E, A>): USTM<boolean> => {
+    return TFuture.reverseGet(self).get.flatMap((mea) =>
+      mea.match(
+        () =>
+          TFuture.reverseGet(self)
+            .set(Just(v))
+            .flatMap(() => STM.succeedNow(true)),
+        () => STM.succeedNow(false),
+      ),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.TFuture fail
+ * @tsplus pipeable fncts.io.TFuture fail
  */
-export function fail_<E, A>(self: TFuture<E, A>, e: E, __tsplusTrace?: string): USTM<boolean> {
-  return self.done(Either.left(e));
+export function fail<E>(e: E, __tsplusTrace?: string) {
+  return <A>(self: TFuture<E, A>): USTM<boolean> => {
+    return self.done(Either.left(e));
+  };
 }
 
 /**
@@ -28,10 +32,12 @@ export function poll<E, A>(self: TFuture<E, A>, __tsplusTrace?: string): USTM<Ma
 }
 
 /**
- * @tsplus fluent fncts.io.TFuture succeed
+ * @tsplus pipeable fncts.io.TFuture succeed
  */
-export function succeed_<E, A>(self: TFuture<E, A>, a: A, __tsplusTrace?: string): USTM<boolean> {
-  return self.done(Either.right(a));
+export function succeed<A>(a: A, __tsplusTrace?: string) {
+  return <E>(self: TFuture<E, A>): USTM<boolean> => {
+    return self.done(Either.right(a));
+  };
 }
 
 /**

package/_src/TFuture/definition.ts

@@ -1,5 +1,4 @@
 import type { UTRef } from "../TRef.js";
-
 interface TFutureN extends HKT {
   readonly type: TFuture<this["E"], this["A"]>;
 }

package/_src/TReentrantLock/api.ts

@@ -87,21 +87,25 @@ export function releaseWrite(self: TReentrantLock, __tsplusTrace?: string): USTM
 }
 
 /**
- * @tsplus fluent fncts.io.TReentrantLock withReadLock
+ * @tsplus pipeable fncts.io.TReentrantLock withReadLock
  */
-export function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.uninterruptibleMask(
-    ({ restore }) => restore(self.acquireRead.commit) > restore(io).ensuring(self.releaseRead.commit),
-  );
+export function withReadLock<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) {
+  return (self: TReentrantLock): IO<R, E, A> => {
+    return IO.uninterruptibleMask(
+      ({ restore }) => restore(self.acquireRead.commit) > restore(io).ensuring(self.releaseRead.commit),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.TReentrantLock withWriteLock
+ * @tsplus pipeable fncts.io.TReentrantLock withWriteLock
  */
-export function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.uninterruptibleMask(
-    ({ restore }) => restore(self.acquireWrite.commit) > restore(io).ensuring(self.releaseWrite.commit),
-  );
+export function withWriteLock<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) {
+  return (self: TReentrantLock): IO<R, E, A> => {
+    return IO.uninterruptibleMask(
+      ({ restore }) => restore(self.acquireWrite.commit) > restore(io).ensuring(self.releaseWrite.commit),
+    );
+  };
 }
 
 /**

package/_src/TReentrantLock/definition.ts

@@ -20,19 +20,16 @@
 export class TReentrantLock {
   constructor(readonly data: UTRef<LockState>) {}
 }
-
 export interface Lock {
   readonly readLocks: number;
   readonly readLocksHeld: (fiberId: FiberId) => number;
   readonly writeLocks: number;
   readonly writeLocksHeld: (fiberId: FiberId) => number;
 }
-
 export const enum LockTag {
   WriteLock,
   ReadLock,
 }
-
 /**
  * @tsplus type fncts.io.TReentrantLock.WriteLock
  * @tsplus companion fncts.io.TReentrantLock.WriteLockOps
@@ -47,7 +44,6 @@ export class WriteLock implements Lock {
     return this.fiberId == fiberId ? this.writeLocks : 0;
   }
 }
-
 /**
  * @tsplus type fncts.io.TReentrantLock.ReadLock
  * @tsplus companion fncts.io.TReentrantLock.ReadLockOps
@@ -59,14 +55,12 @@ export class ReadLock implements Lock {
     return (this.readers.values as Iterable<number>).sum;
   }
   writeLocks = 0;
-
   readLocksHeld(fiberId: FiberId) {
     return this.readers.get(fiberId).getOrElse(0);
   }
   writeLocksHeld(_fiberId: FiberId) {
     return 0;
   }
-
   noOtherHolder(fiberId: FiberId): boolean {
     return this.readers.isEmpty || (this.readers.size === 1 && this.readers.has(fiberId));
   }
@@ -82,5 +76,4 @@ export class ReadLock implements Lock {
     return new ReadLock(this.readers.set(fiberId, newTotal));
   }
 }
-
 export type LockState = WriteLock | ReadLock;

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