@fncts/io 0.0.9 → 0.0.10

package/_src/TFuture/definition.ts

@@ -20,4 +20,4 @@ export interface TFuture<E, A>
  */
 export interface TFutureOps extends NewtypeIso<TFutureN> {}
 
-export const TFuture: TFutureOps = Newtype<TFutureN>();
+export const TFuture: TFutureOps = Newtype<TFutureN>();

package/_src/TReentrantLock/api.ts

@@ -0,0 +1,193 @@
+import type { Lock, LockState } from "./definition.js";
+
+import { RetryException } from "../STM.js";
+import { ReadLock, TReentrantLock } from "./definition.js";
+import { LockTag, WriteLock } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.TReentrantLock.ReadLockOps empty
+ */
+export const emptyReadLock: ReadLock = new ReadLock(HashMap.makeDefault());
+
+/**
+ * @tsplus static fncts.io.TReentrantLock.ReadLockOps __call
+ */
+export function makeReadLock(fiberId: FiberId, count: number): ReadLock {
+  return count <= 0 ? ReadLock.empty : new ReadLock(HashMap.makeDefault<FiberId, number>().set(fiberId, count));
+}
+
+/**
+ * @tsplus static fncts.io.TReentrantLockOps make
+ * @tsplus static fncts.io.TReentrantLockOps __call
+ */
+export function make(): USTM<TReentrantLock> {
+  return TRef.make<LockState>(new ReadLock(HashMap.makeDefault())).map((ref) => new TReentrantLock(ref));
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock acquireRead
+ */
+export function acquireRead(self: TReentrantLock): USTM<number> {
+  return adjustRead(self, 1);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock acquireWrite
+ */
+export function acquireWrite(self: TReentrantLock): USTM<number> {
+  return STM.Effect((journal, fiberId, _) => {
+    const lockState = self.data.unsafeGet(journal);
+    switch (lockState._tag) {
+      case LockTag.ReadLock: {
+        if (lockState.noOtherHolder(fiberId)) {
+          self.data.unsafeSet(journal, new WriteLock(1, lockState.readLocksHeld(fiberId), fiberId));
+          return 1;
+        }
+        throw new RetryException();
+      }
+      case LockTag.WriteLock: {
+        if (lockState.fiberId == fiberId) {
+          self.data.unsafeSet(journal, new WriteLock(lockState.writeLocks + 1, lockState.readLocks, fiberId));
+          return lockState.writeLocks + 1;
+        }
+        throw new RetryException();
+      }
+    }
+  });
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock releaseRead
+ */
+export function releaseRead(self: TReentrantLock): USTM<number> {
+  return adjustRead(self, -1);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock releaseWrite
+ */
+export function releaseWrite(self: TReentrantLock): USTM<number> {
+  return STM.Effect((journal, fiberId) => {
+    const lockState: LockState = self.data.unsafeGet(journal);
+    let res: LockState | undefined;
+    if (lockState._tag === LockTag.WriteLock && lockState.fiberId == fiberId) {
+      if (lockState.writeLocks === 1) {
+        res = new ReadLock(HashMap.makeDefault<FiberId, number>().set(fiberId, lockState.readLocks));
+      }
+      if (lockState.writeLocks > 1) {
+        res = new WriteLock(lockState.writeLocks - 1, lockState.readLocks, fiberId);
+      }
+    }
+    if (!res) {
+      throw new Error(`Defect: Fiber ${fiberId.threadName} releasing write lock it does not hold`);
+    }
+    self.data.unsafeSet(journal, res);
+    return res.writeLocksHeld(fiberId);
+  });
+}
+
+/**
+ * @tsplus fluent fncts.io.TReentrantLock withReadLock
+ */
+export function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): IO<R, E, A> {
+  return IO.uninterruptibleMask(
+    ({ restore }) => restore(self.acquireRead.commit) > restore(io).ensuring(self.releaseRead.commit),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.io.TReentrantLock withWriteLock
+ */
+export function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): IO<R, E, A> {
+  return IO.uninterruptibleMask(
+    ({ restore }) => restore(self.acquireWrite.commit) > restore(io).ensuring(self.releaseWrite.commit),
+  );
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock readLock
+ */
+export function readLock(self: TReentrantLock, __tsplusTrace?: string): IO<Has<Scope>, never, number> {
+  return self.acquireRead.commit.acquireRelease(() => self.releaseRead.commit);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock writeLock
+ */
+export function writeLock(self: TReentrantLock, __tsplusTrace?: string): IO<Has<Scope>, never, number> {
+  return self.acquireWrite.commit.acquireRelease(() => self.releaseWrite.commit);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock readLocked
+ */
+export function readLocked(self: TReentrantLock): USTM<boolean> {
+  return self.data.get.map((state) => state.readLocks > 0);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock writeLocked
+ */
+export function writeLocked(self: TReentrantLock): USTM<boolean> {
+  return self.data.get.map((state) => state.writeLocks > 0);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock locked
+ */
+export function locked(self: TReentrantLock): USTM<boolean> {
+  return self.readLocked.zipWith(self.writeLocked, (a, b) => a || b);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock fiberReadLocks
+ */
+export function fiberReadLocks(self: TReentrantLock): USTM<number> {
+  return STM.Effect((journal, fiberId) => self.data.unsafeGet(journal).readLocksHeld(fiberId));
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock fiberWriteLocks
+ */
+export function fiberWriteLocks(self: TReentrantLock): USTM<number> {
+  return STM.Effect((journal, fiberId) => self.data.unsafeGet(journal).writeLocksHeld(fiberId));
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock writeLocks
+ */
+export function writeLocks(self: TReentrantLock): USTM<number> {
+  return self.data.get.map((state) => state.writeLocks);
+}
+
+/**
+ * @tsplus getter fncts.io.TReentrantLock readLocks
+ */
+export function readLocks(self: TReentrantLock): USTM<number> {
+  return self.data.get.map((state) => state.readLocks);
+}
+
+function adjustRead(self: TReentrantLock, delta: number): USTM<number> {
+  return STM.Effect((journal, fiberId, _) => {
+    const lockState = self.data.unsafeGet(journal);
+    switch (lockState._tag) {
+      case LockTag.ReadLock: {
+        const res = lockState.adjust(fiberId, delta);
+        self.data.unsafeSet(journal, res);
+        return res.readLocksHeld(fiberId);
+      }
+      case LockTag.WriteLock: {
+        if (!lockState.fiberId == fiberId) {
+          throw new RetryException();
+        }
+        const newTotal = lockState.writeLocks + delta;
+        if (newTotal < 0) {
+          throw new Error(`Defect: Fiber ${lockState.fiberId.threadName} releasing read lock it does not hold`);
+        } else {
+          self.data.unsafeSet(journal, new WriteLock(lockState.writeLocks, newTotal, lockState.fiberId));
+        }
+        return newTotal;
+      }
+    }
+  });
+}

package/_src/TReentrantLock/definition.ts

@@ -0,0 +1,86 @@
+/**
+ * A `TReentrantLock` is a reentrant read/write lock. Multiple readers may all
+ * concurrently acquire read locks. Only one writer is allowed to acquire a
+ * write lock at any given time. Read locks may be upgraded into write locks. A
+ * fiber that has a write lock may acquire other write locks or read locks.
+ *
+ * The two primary methods of this structure are `readLock`, which acquires a
+ * read lock in a scoped context, and `writeLock`, which acquires a write lock
+ * in a scoped context.
+ *
+ * Although located in the STM package, there is no need for locks within STM
+ * transactions. However, this lock can be quite useful in effectful code, to
+ * provide consistent read/write access to mutable state; and being in STM
+ * allows this structure to be composed into more complicated concurrent
+ * structures that are consumed from effectful code.
+ *
+ * @tsplus type fncts.io.TReentrantLock
+ * @tsplus companion fncts.io.TReentrantLockOps
+ */
+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
+ */
+export class WriteLock implements Lock {
+  readonly _tag = LockTag.WriteLock;
+  constructor(readonly writeLocks: number, readonly readLocks: number, readonly fiberId: FiberId) {}
+  readLocksHeld(fiberId: FiberId): number {
+    return this.fiberId == fiberId ? this.readLocks : 0;
+  }
+  writeLocksHeld(fiberId: FiberId): number {
+    return this.fiberId == fiberId ? this.writeLocks : 0;
+  }
+}
+
+/**
+ * @tsplus type fncts.io.TReentrantLock.ReadLock
+ * @tsplus companion fncts.io.TReentrantLock.ReadLockOps
+ */
+export class ReadLock implements Lock {
+  readonly _tag = LockTag.ReadLock;
+  constructor(readonly readers: HashMap<FiberId, number>) {}
+  get readLocks() {
+    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));
+  }
+  adjust(fiberId: FiberId, adjust: number): ReadLock {
+    const total    = this.readLocksHeld(fiberId);
+    const newTotal = total + adjust;
+    if (newTotal < 0) {
+      throw new Error(`Defect: Fiber ${fiberId.threadName} releasing read lock it does not hold`);
+    }
+    if (newTotal === 0) {
+      return new ReadLock(this.readers.remove(fiberId));
+    }
+    return new ReadLock(this.readers.set(fiberId, newTotal));
+  }
+}
+
+export type LockState = WriteLock | ReadLock;

package/_src/TReentrantLock.ts

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

package/_src/collection/immutable/Conc/filterIO.ts

@@ -0,0 +1,16 @@
+/**
+ * @tsplus fluent fncts.Conc filterIO
+ */
+export function filterIO<A, R, E>(self: Conc<A>, p: (a: A) => IO<R, E, boolean>): IO<R, E, Conc<A>> {
+  return IO.defer(() => {
+    const builder = new ConcBuilder<A>();
+    let dest: IO<R, E, ConcBuilder<A>> = IO.succeedNow(builder);
+    for (const a of self) {
+      dest = dest.zipWith(p(a), (builder, res) => {
+        if (res) return builder.append(a);
+        else return builder;
+      });
+    }
+    return dest.map((builder) => builder.result());
+  });
+}

package/_src/collection/immutable/Conc.ts

@@ -1,4 +1,5 @@
 // codegen:start { preset: barrel, include: ./Conc/*.ts }
+export * from "./Conc/filterIO.js";
 export * from "./Conc/findIO.js";
 export * from "./Conc/mapIO.js";
 export * from "./Conc/takeWhileIO.js";

package/collection/immutable/Conc/filterIO.d.ts

@@ -0,0 +1,7 @@
+import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.Conc filterIO
+ * @tsplus location "@fncts/io/collection/immutable/Conc/filterIO"
+ */
+export declare function filterIO<A, R, E>(self: Conc<A>, p: (a: A) => IO<R, E, boolean>): IO<R, E, Conc<A>>;

package/collection/immutable/Conc.d.ts

@@ -1,3 +1,4 @@
+export * from "./Conc/filterIO.js";
 export * from "./Conc/findIO.js";
 export * from "./Conc/mapIO.js";
 export * from "./Conc/takeWhileIO.js";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "dependencies": {
-    "@fncts/base": "0.0.9",
-    "@fncts/typelevel": "0.0.7"
+    "@fncts/base": "0.0.10",
+    "@fncts/typelevel": "0.0.8"
   },
   "exports": {
     "./*": {