@fncts/io 0.0.9 → 0.0.10

package/_mjs/TReentrantLock/definition.mjs

@@ -0,0 +1,102 @@
+import * as tsplus_module_1 from "@fncts/base/typeclass/Equatable/api";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/HashMap/api";
+import * as tsplus_module_3 from "@fncts/base/collection/Iterable/api";
+import * as tsplus_module_4 from "@fncts/base/data/Maybe/api";
+import * as tsplus_module_5 from "@fncts/base/data/FiberId/api";
+/**
+ * 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(data) {
+    this.data = data;
+  }
+
+}
+/**
+ * @tsplus type fncts.io.TReentrantLock.WriteLock
+ * @tsplus companion fncts.io.TReentrantLock.WriteLockOps
+ */
+
+export class WriteLock {
+  constructor(writeLocks, readLocks, fiberId) {
+    this.writeLocks = writeLocks;
+    this.readLocks = readLocks;
+    this.fiberId = fiberId;
+    this._tag = 0
+    /* LockTag.WriteLock */
+    ;
+  }
+
+  readLocksHeld(fiberId) {
+    return tsplus_module_1.strictEquals(this.fiberId, fiberId) ? this.readLocks : 0;
+  }
+
+  writeLocksHeld(fiberId) {
+    return tsplus_module_1.strictEquals(this.fiberId, fiberId) ? this.writeLocks : 0;
+  }
+
+}
+/**
+ * @tsplus type fncts.io.TReentrantLock.ReadLock
+ * @tsplus companion fncts.io.TReentrantLock.ReadLockOps
+ */
+
+export class ReadLock {
+  constructor(readers) {
+    this.readers = readers;
+    this._tag = 1
+    /* LockTag.ReadLock */
+    ;
+    this.writeLocks = 0;
+  }
+
+  get readLocks() {
+    return tsplus_module_3.sum(tsplus_module_2.values(this.readers));
+  }
+
+  readLocksHeld(fiberId) {
+    return tsplus_module_4.getOrElse_(tsplus_module_2.get_(this.readers, fiberId), () => 0);
+  }
+
+  writeLocksHeld(_fiberId) {
+    return 0;
+  }
+
+  noOtherHolder(fiberId) {
+    return tsplus_module_2.isEmpty(this.readers) || this.readers.size === 1 && tsplus_module_2.has_(this.readers, fiberId);
+  }
+
+  adjust(fiberId, adjust) {
+    const total = this.readLocksHeld(fiberId);
+    const newTotal = total + adjust;
+
+    if (newTotal < 0) {
+      throw new Error(`Defect: Fiber ${tsplus_module_5.threadName(fiberId)} releasing read lock it does not hold`);
+    }
+
+    if (newTotal === 0) {
+      return new ReadLock(tsplus_module_2.remove_(this.readers, fiberId));
+    }
+
+    return new ReadLock(tsplus_module_2.set_(this.readers, fiberId, newTotal));
+  }
+
+}
+//# sourceMappingURL=definition.mjs.map

package/_mjs/TReentrantLock/definition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.mjs","mappings":";;;;;AAAA;;;;;;;;;;;;;;;;;;;;AAmBA,OAAM,MAAOA,cAAP,CAAqB;EACzBC,YAAqBC,IAArB,EAA2C;IAAtB;EAA0B;;AADtB;AAgB3B;;;;;AAIA,OAAM,MAAOC,SAAP,CAAgB;EAEpBF,YAAqBG,UAArB,EAAkDC,SAAlD,EAA8EC,OAA9E,EAA8F;IAAzE;IAA6B;IAA4B;IADrE,YAAI;IAAA;IAAJ;EACyF;;EAClGC,aAAa,CAACD,OAAD,EAAiB;IAC5B,OAAOE,kCAAKF,OAAL,EAAgBA,OAAhB,IAA0B,KAAKD,SAA/B,GAA2C,CAAlD;EACD;;EACDI,cAAc,CAACH,OAAD,EAAiB;IAC7B,OAAOE,kCAAKF,OAAL,EAAgBA,OAAhB,IAA0B,KAAKF,UAA/B,GAA4C,CAAnD;EACD;;AARmB;AAWtB;;;;;AAIA,OAAM,MAAOM,QAAP,CAAe;EAEnBT,YAAqBU,OAArB,EAAsD;IAAjC;IADZ,YAAI;IAAA;IAAJ;IAKT,kBAAa,CAAb;EAJ0D;;EAC7C,IAATN,SAAS;IACX,2BAAQO,4BAAKD,OAAL,CAAR;EACD;;EAGDJ,aAAa,CAACD,OAAD,EAAiB;IAC5B,OAAOO,qDAAKF,OAAL,EAAiBL,OAAjB,GAAyB,MAAW,CAApC,CAAP;EACD;;EACDG,cAAc,CAACK,QAAD,EAAkB;IAC9B,OAAO,CAAP;EACD;;EAEDC,aAAa,CAACT,OAAD,EAAiB;IAC5B,OAAOM,6BAAKD,OAAL,KAAyB,KAAKA,OAAL,CAAaK,IAAb,KAAsB,CAAtB,IAA2BJ,0BAAKD,OAAL,EAAiBL,OAAjB,CAA3D;EACD;;EACDW,MAAM,CAACX,OAAD,EAAmBW,MAAnB,EAAiC;IACrC,MAAMC,KAAK,GAAM,KAAKX,aAAL,CAAmBD,OAAnB,CAAjB;IACA,MAAMa,QAAQ,GAAGD,KAAK,GAAGD,MAAzB;;IACA,IAAIE,QAAQ,GAAG,CAAf,EAAkB;MAChB,MAAM,IAAIC,KAAJ,CAAU,iBAAiBC,mCAAkB,uCAA7C,CAAN;IACD;;IACD,IAAIF,QAAQ,KAAK,CAAjB,EAAoB;MAClB,OAAO,IAAIT,QAAJ,CAAaE,6BAAKD,OAAL,EAAoBL,OAApB,CAAb,CAAP;IACD;;IACD,OAAO,IAAII,QAAJ,CAAaE,0BAAKD,OAAL,EAAiBL,OAAjB,EAA0Ba,QAA1B,CAAb,CAAP;EACD;;AA5BkB","names":["TReentrantLock","constructor","data","WriteLock","writeLocks","readLocks","fiberId","readLocksHeld","tsplus_module_1","writeLocksHeld","ReadLock","readers","tsplus_module_2","tsplus_module_4","_fiberId","noOtherHolder","size","adjust","total","newTotal","Error","tsplus_module_5"],"sourceRoot":"","sources":["../../_src/TReentrantLock/definition.ts"],"sourcesContent":[null]}

package/_mjs/TReentrantLock.mjs

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: TReentrantLock/*.ts }
+export * from "./TReentrantLock/api.mjs";
+export * from "./TReentrantLock/definition.mjs";
+//# sourceMappingURL=TReentrantLock.mjs.map

package/_mjs/TReentrantLock.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TReentrantLock.mjs","mappings":"AAAA;AACA,cAAc,0BAAd;AACA,cAAc,iCAAd","names":[],"sourceRoot":"","sources":["../_src/TReentrantLock.ts"],"sourcesContent":[null]}

package/_mjs/collection/immutable/Conc/filterIO.mjs

@@ -0,0 +1,22 @@
+const fileName_1 = "(@fncts/io) src/collection/immutable/Conc/filterIO.ts";
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/Conc";
+import * as tsplus_module_2 from "@fncts/io/IO/api";
+/**
+ * @tsplus fluent fncts.Conc filterIO
+ */
+
+export function filterIO(self, p) {
+  return tsplus_module_2.defer(() => {
+    const builder = new tsplus_module_1.ConcBuilder();
+    let dest = tsplus_module_2.succeedNow(builder, fileName_1 + ":7:55");
+
+    for (const a of self) {
+      dest = tsplus_module_2.zipWith_(dest, p(a), (builder, res) => {
+        if (res) return builder.append(a);else return builder;
+      });
+    }
+
+    return tsplus_module_2.map_(dest, builder => builder.result(), fileName_1 + ":14:20");
+  }, fileName_1 + ":5:18");
+}
+//# sourceMappingURL=filterIO.mjs.map

package/_mjs/collection/immutable/Conc/filterIO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterIO.mjs","mappings":";;;AAAA;;;;AAGA,OAAM,SAAUA,QAAV,CAA4BC,IAA5B,EAA2CC,CAA3C,EAAyE;EAC7E,OAAOC,sBAAS,MAAK;IACnB,MAAMC,OAAO,GAAG,oBAAIC,WAAJ,EAAhB;IACA,IAAIC,IAAI,GAA6BH,2BAAcC,OAAd,EAAqBG,oBAArB,CAArC;;IACA,KAAK,MAAMC,CAAX,IAAgBP,IAAhB,EAAsB;MACpBK,IAAI,GAAGH,+BAAaD,CAAC,CAACM,CAAD,CAAd,EAAmB,CAACJ,OAAD,EAAUK,GAAV,KAAiB;QACzC,IAAIA,GAAJ,EAAS,OAAOL,OAAO,CAACM,MAAR,CAAeF,CAAf,CAAP,CAAT,KACK,OAAOJ,OAAP;MACN,CAHM,CAAP;IAID;;IACD,OAAOD,2BAAUC,OAAD,IAAaA,OAAO,CAACO,MAAR,EAAtB,EAAsCJ,qBAAtC,CAAP;EACD,CAVM,EAUNA,oBAVM,CAAP;AAWD","names":["filterIO","self","p","tsplus_module_2","builder","ConcBuilder","dest","fileName_1","a","res","append","result"],"sourceRoot":"","sources":["../../../../_src/collection/immutable/Conc/filterIO.ts"],"sourcesContent":[null]}

package/_mjs/collection/immutable/Conc.mjs

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

package/_mjs/collection/immutable/Conc.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Conc.mjs","mappings":"AAAA;AACA,cAAc,mBAAd;AACA,cAAc,kBAAd;AACA,cAAc,wBAAd","names":[],"sourceRoot":"","sources":["../../../_src/collection/immutable/Conc.ts"],"sourcesContent":[null]}
+{"version":3,"file":"Conc.mjs","mappings":"AAAA;AACA,cAAc,qBAAd;AACA,cAAc,mBAAd;AACA,cAAc,kBAAd;AACA,cAAc,wBAAd","names":[],"sourceRoot":"","sources":["../../../_src/collection/immutable/Conc.ts"],"sourcesContent":[null]}

package/_src/Channel/api.ts

@@ -231,6 +231,23 @@ export function catchAllCause_<
   >(self, new ContinuationK((_) => Channel.endNow(_), f));
 }
 
+/**
+ * @tsplus getter fncts.io.Channel collectElements
+ */
+export function collectElements<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+): Channel<Env, InErr, InElem, InDone, OutErr, never, readonly [Conc<OutElem>, OutDone]> {
+  return Channel.defer(() => {
+    const builder = new ConcBuilder<OutElem>(Conc.empty());
+    const reader: Channel<Env, OutErr, OutElem, OutDone, OutErr, never, OutDone> = Channel.readWith(
+      (out) => Channel.succeed(builder.append(out)) > reader,
+      Channel.failNow,
+      Channel.succeedNow,
+    );
+    return self.pipeTo(reader).flatMap((z) => Channel.succeedNow([builder.result(), z]));
+  });
+}
+
 /**
  * @tsplus getter fncts.io.Channel concatAll
  */
@@ -735,9 +752,9 @@ export function fromQueue<Err, Elem, Done>(
  */
 export function provideEnvironment_<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
   self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  env: Environment<Env>,
+  env: Lazy<Environment<Env>>,
 ): Channel<unknown, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  return new Provide(env, self);
+  return Channel.defer(new Provide(env(), self));
 }
 
 /**
@@ -945,6 +962,49 @@ export function matchCauseChannel_<
   );
 }
 
+/**
+ * Fold the channel exposing success and full error cause
+ *
+ * @tsplus fluent fncts.io.Channel matchChannel
+ */
+export function matchChannel_<
+  Env,
+  Env1,
+  Env2,
+  InErr,
+  InErr1,
+  InErr2,
+  InElem,
+  InElem1,
+  InElem2,
+  InDone,
+  InDone1,
+  InDone2,
+  OutErr,
+  OutErr2,
+  OutErr3,
+  OutElem,
+  OutElem1,
+  OutElem2,
+  OutDone,
+  OutDone2,
+  OutDone3,
+>(
+  channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  onError: (e: OutErr) => Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>,
+  onSuccess: (o: OutDone) => Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>,
+): Channel<
+  Env & Env1 & Env2,
+  InErr & InErr1 & InErr2,
+  InElem & InElem1 & InElem2,
+  InDone & InDone1 & InDone2,
+  OutErr2 | OutErr3,
+  OutElem | OutElem1 | OutElem2,
+  OutDone2 | OutDone3
+> {
+  return channel.matchCauseChannel((cause) => cause.failureOrCause.match(onError, Channel.failCauseNow), onSuccess);
+}
+
 export const never: Channel<unknown, unknown, unknown, unknown, never, never, never> = Channel.fromIO(IO.never);
 
 /**
@@ -1007,6 +1067,7 @@ export function orHaltWith_<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone
  * Pipe the output of a channel into the input of another
  *
  * @tsplus fluent fncts.io.Channel pipeTo
+ * @tsplus operator fncts.io.Channel >>>
  */
 export function pipeTo_<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, OutErr1, OutElem1, OutDone1>(
   left: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
@@ -1174,16 +1235,24 @@ export function repeated<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 }
 
 /**
- * @tsplus static fncts.io.Channel toQueue
+ * @tsplus static fncts.io.ChannelOps toQueue
  */
 export function toQueue<Err, Done, Elem>(
-  queue: Queue.Enqueue<Either<Exit<Err, Done>, Elem>>,
-): Channel<unknown, Err, Elem, Done, never, never, any> {
-  return readWithCause(
-    (in_: Elem) => Channel.fromIO(queue.offer(Either.right(in_))).apSecond(toQueue(queue)),
-    (cause: Cause<Err>) => Channel.fromIO(queue.offer(Either.left(Exit.failCause(cause)))),
-    (done: Done) => Channel.fromIO(queue.offer(Either.left(Exit.succeed(done)))),
-  );
+  queue: Lazy<Queue.Enqueue<Either<Exit<Err, Done>, Elem>>>,
+): Channel<unknown, Err, Elem, Done, never, never, unknown> {
+  return Channel.defer(() => {
+    function toQueue<Err, Done, Elem>(
+      queue: Queue.Enqueue<Either<Exit<Err, Done>, Elem>>,
+    ): Channel<unknown, Err, Elem, Done, never, never, unknown> {
+      return Channel.readWithCause(
+        (inp) => Channel.fromIO(queue.offer(Either.right(inp))) > toQueue(queue),
+        (cause) => Channel.fromIO(queue.offer(Either.left(Exit.failCause(cause)))),
+        (done) => Channel.fromIO(queue.offer(Either.left(Exit.succeed(done)))),
+      );
+    }
+
+    return toQueue(queue());
+  });
 }
 
 /**
@@ -1249,10 +1318,28 @@ export function unwrap<R, E, Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
  * @tsplus static fncts.io.ChannelOps unwrapScoped
  */
 export function unwrapScoped<R, E, Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: IO<R & Has<Scope>, E, Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>,
+  self: Lazy<IO<R & Has<Scope>, E, Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>>,
 ): Channel<R & Env, InErr, InElem, InDone, E | OutErr, OutElem, OutDone> {
   return Channel.scoped(self).concatAllWith(
     (d, _) => d,
     (d, _) => d,
   );
 }
+
+/**
+ * @tsplus static fncts.io.ChannelOps fromHubScoped
+ */
+export function fromHubScoped<Err, Done, Elem>(
+  hub: Lazy<Hub<Either<Exit<Err, Done>, Elem>>>,
+): IO<Has<Scope>, never, Channel<unknown, unknown, unknown, unknown, Err, Elem, Done>> {
+  return IO.defer(hub().subscribe.map(Channel.fromQueue));
+}
+
+/**
+ * @tsplus static fncts.io.ChannelOps toHub
+ */
+export function toHub<Err, Done, Elem>(
+  hub: Lazy<Hub<Either<Exit<Err, Done>, Elem>>>,
+): Channel<unknown, Err, Elem, Done, never, never, unknown> {
+  return Channel.toQueue(hub);
+}

package/_src/Channel/internal/MergeDecision.ts

@@ -19,6 +19,21 @@ export abstract class MergeDecision<R, E0, Z0, E, Z> {
   readonly _Z!: () => Z;
 }
 
+/**
+ * @tsplus unify fncts.io.Channel.MergeDecision
+ */
+export function unifyMergeDecision<X extends MergeDecision<any, any, any, any, any>>(
+  _: X,
+): MergeDecision<
+  [X] extends [MergeDecision<infer R, any, any, any, any>] ? R : never,
+  [X] extends [MergeDecision<any, infer E0, any, any, any>] ? E0 : never,
+  [X] extends [MergeDecision<any, any, infer Z0, any, any>] ? Z0 : never,
+  [X] extends [MergeDecision<any, any, any, infer E, any>] ? E : never,
+  [X] extends [MergeDecision<any, any, any, any, infer Z>] ? Z : never
+> {
+  return _;
+}
+
 /**
  * @tsplus fluent fncts.io.Channel.MergeDecision concrete
  * @tsplus macro remove

package/_src/IO/api.ts

@@ -99,7 +99,7 @@ export function asyncInterrupt<R, E, A>(
  * @tsplus fluent fncts.io.IO absorbWith
  */
 export function absorbWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string) {
-  return ma.sandbox.matchIO((cause) => IO.failNow(cause.squashWith(f)), IO.succeedNow)
+  return ma.sandbox.matchIO((cause) => IO.failNow(cause.squashWith(f)), IO.succeedNow);
 }
 
 /**

package/_src/STM/api.ts

@@ -1,3 +1,5 @@
+import type { Journal} from "./internal/Journal.js";
+
 import { identity } from "@fncts/base/data/function";
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import { TxnId } from "@fncts/io/TxnId";
@@ -44,6 +46,13 @@ export function absolve<R, E, E1, A>(z: STM<R, E, Either<E1, A>>): STM<R, E | E1
   return z.flatMap(STM.fromEitherNow);
 }
 
+/**
+ * @tsplus static fncts.io.STMOps Effect
+ */
+export function makeEffect<R, E, A>(f: (journal: Journal, fiberId: FiberId, r: R) => A): STM<R, E, A> {
+  return new Effect(f);
+}
+
 /**
  * Retrieves the environment inside an stm.
  *