@fncts/io 0.0.19 → 0.0.21

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
  */

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

@@ -1,24 +1,22 @@
 /**
- * @tsplus fluent fncts.Conc dropUntilIO
+ * @tsplus pipeable fncts.Conc dropUntilIO
  */
-export function dropUntilIO<A, R, E>(
-  self: Conc<A>,
-  p: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): IO<R, E, Conc<A>> {
-  return IO.defer(() => {
-    const builder                   = new ConcBuilder<A>();
-    let dropping: IO<R, E, boolean> = IO.succeedNow(false);
-    for (const elem of self) {
-      dropping = dropping.flatMap((b) => {
-        if (b) {
-          builder.append(elem);
-          return IO.succeedNow(true);
-        } else {
-          return p(elem);
-        }
-      });
-    }
-    return dropping.as(builder.result());
-  });
+export function dropUntilIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (self: Conc<A>): IO<R, E, Conc<A>> => {
+    return IO.defer(() => {
+      const builder                   = new ConcBuilder<A>();
+      let dropping: IO<R, E, boolean> = IO.succeedNow(false);
+      for (const elem of self) {
+        dropping = dropping.flatMap((b) => {
+          if (b) {
+            builder.append(elem);
+            return IO.succeedNow(true);
+          } else {
+            return p(elem);
+          }
+        });
+      }
+      return dropping.as(builder.result());
+    });
+  };
 }

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

@@ -1,26 +1,24 @@
 /**
- * @tsplus fluent fncts.Conc dropWhileIO
+ * @tsplus pipeable fncts.Conc dropWhileIO
  */
-export function dropWhileIO<A, R, E>(
-  self: Conc<A>,
-  p: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): IO<R, E, Conc<A>> {
-  return IO.defer(() => {
-    const builder                   = new ConcBuilder<A>();
-    let dropping: IO<R, E, boolean> = IO.succeedNow(true);
-    for (const elem of self) {
-      dropping = dropping.flatMap((d) =>
-        (d ? p(elem) : IO.succeedNow(false)).map((b) => {
-          if (b) {
-            return true;
-          } else {
-            builder.append(elem);
-            return false;
-          }
-        }),
-      );
-    }
-    return dropping.as(builder.result());
-  });
+export function dropWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (self: Conc<A>): IO<R, E, Conc<A>> => {
+    return IO.defer(() => {
+      const builder                   = new ConcBuilder<A>();
+      let dropping: IO<R, E, boolean> = IO.succeedNow(true);
+      for (const elem of self) {
+        dropping = dropping.flatMap((d) =>
+          (d ? p(elem) : IO.succeedNow(false)).map((b) => {
+            if (b) {
+              return true;
+            } else {
+              builder.append(elem);
+              return false;
+            }
+          }),
+        );
+      }
+      return dropping.as(builder.result());
+    });
+  };
 }

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

@@ -1,20 +1,18 @@
 /**
- * @tsplus fluent fncts.Conc filterIO
+ * @tsplus pipeable fncts.Conc filterIO
  */
-export function filterIO<A, R, E>(
-  self: Conc<A>,
-  p: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): 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());
-  });
+export function filterIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (self: Conc<A>): 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/findIO.ts

@@ -1,6 +1,6 @@
 import { concrete } from "@fncts/base/collection/immutable/Conc";
 
-function findIOLoop_<R, E, A>(
+function findIOLoop<R, E, A>(
   iterator: Iterator<ArrayLike<A>>,
   f: (a: A) => IO<R, E, boolean>,
   array: ArrayLike<A>,
@@ -10,33 +10,31 @@ function findIOLoop_<R, E, A>(
 ): IO<R, E, Maybe<A>> {
   if (i < length) {
     const a = array[i]!;
-    return f(a).flatMap((b) => (b ? IO.succeedNow(Just(a)) : findIOLoop_(iterator, f, array, i + 1, length)));
+    return f(a).flatMap((b) => (b ? IO.succeedNow(Just(a)) : findIOLoop(iterator, f, array, i + 1, length)));
   }
   let result;
   if (!(result = iterator.next()).done) {
     const arr = result.value;
     const len = arr.length;
-    return findIOLoop_(iterator, f, arr, 0, len);
+    return findIOLoop(iterator, f, arr, 0, len);
   }
   return IO.succeedNow(Nothing());
 }
 
 /**
- * @tsplus fluent fncts.Conc findIO
+ * @tsplus pipeable fncts.Conc findIO
  */
-export function findIO_<R, E, A>(
-  as: Conc<A>,
-  f: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): IO<R, E, Maybe<A>> {
-  concrete(as);
-  const iterator = as.arrayIterator();
-  let result;
-  if (!(result = iterator.next()).done) {
-    const array  = result.value;
-    const length = array.length;
-    return findIOLoop_(iterator, f, array, 0, length);
-  } else {
-    return IO.succeedNow(Nothing());
-  }
+export function findIO<R, E, A>(f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (as: Conc<A>): IO<R, E, Maybe<A>> => {
+    concrete(as);
+    const iterator = as.arrayIterator();
+    let result;
+    if (!(result = iterator.next()).done) {
+      const array  = result.value;
+      const length = array.length;
+      return findIOLoop(iterator, f, array, 0, length);
+    } else {
+      return IO.succeedNow(Nothing());
+    }
+  };
 }

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

@@ -1,13 +1,15 @@
 /**
- * @tsplus fluent fncts.Conc mapIO
+ * @tsplus pipeable fncts.Conc mapIO
  */
-export function mapIO_<A, R, E, B>(as: Conc<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>> {
-  return IO.defer(() => {
-    const out = Conc.builder<B>();
-    return IO.foreachDiscard(as, (a) =>
-      f(a).map((b) => {
-        out.append(b);
-      }),
-    ).as(out.result());
-  });
+export function mapIO<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string) {
+  return (as: Conc<A>): IO<R, E, Conc<B>> => {
+    return IO.defer(() => {
+      const out = Conc.builder<B>();
+      return IO.foreachDiscard(as, (a) =>
+        f(a).map((b) => {
+          out.append(b);
+        }),
+      ).as(out.result());
+    });
+  };
 }

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

@@ -1,36 +1,34 @@
 import { concrete } from "@fncts/base/collection/immutable/Conc";
 
 /**
- * @tsplus fluent fncts.Conc takeWhileIO
+ * @tsplus pipeable fncts.Conc takeWhileIO
  */
-export function takeWhileIO_<A, R, E>(
-  as: Conc<A>,
-  p: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): IO<R, E, Conc<A>> {
-  return IO.defer(() => {
-    concrete(as);
-    let taking: IO<R, E, boolean> = IO.succeedNow(true);
-    const out                     = Conc.builder<A>();
-    const iterator                = as.arrayIterator();
-    let result: IteratorResult<ArrayLike<A>>;
-    while (!(result = iterator.next()).done) {
-      const array = result.value;
-      for (let i = 0; i < array.length; i++) {
-        const j = i;
-        taking  = taking.flatMap((b) => {
-          const a = array[j]!;
-          return (b ? p(a) : IO.succeedNow(false)).map((b1) => {
-            if (b1) {
-              out.append(a);
-              return true;
-            } else {
-              return false;
-            }
+export function takeWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (as: Conc<A>): IO<R, E, Conc<A>> => {
+    return IO.defer(() => {
+      concrete(as);
+      let taking: IO<R, E, boolean> = IO.succeedNow(true);
+      const out                     = Conc.builder<A>();
+      const iterator                = as.arrayIterator();
+      let result: IteratorResult<ArrayLike<A>>;
+      while (!(result = iterator.next()).done) {
+        const array = result.value;
+        for (let i = 0; i < array.length; i++) {
+          const j = i;
+          taking  = taking.flatMap((b) => {
+            const a = array[j]!;
+            return (b ? p(a) : IO.succeedNow(false)).map((b1) => {
+              if (b1) {
+                out.append(a);
+                return true;
+              } else {
+                return false;
+              }
+            });
           });
-        });
+        }
       }
-    }
-    return taking.as(out.result());
-  });
+      return taking.as(out.result());
+    });
+  };
 }

package/_src/data/Exit/foreachIO.ts

@@ -2,15 +2,13 @@
  * Applies the function `f` to the successful result of the `Exit` and
  * returns the result in a new `Exit`.
  *
- * @tsplus fluent fncts.Exit foreachIO
+ * @tsplus pipeable fncts.Exit foreachIO
  */
-export function foreachIO_<E2, A2, R, E, A>(
-  exit: Exit<E2, A2>,
-  f: (a: A2) => IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R, never, Exit<E | E2, A>> {
-  return exit.match(
-    (c): URIO<R, Exit<E | E2, A>> => IO.succeedNow(Exit.failCause(c)),
-    (a) => f(a).result,
-  );
+export function foreachIO<A2, R, E, A>(f: (a: A2) => IO<R, E, A>, __tsplusTrace?: string) {
+  return <E2>(exit: Exit<E2, A2>): IO<R, never, Exit<E | E2, A>> => {
+    return exit.match(
+      (c): URIO<R, Exit<E | E2, A>> => IO.succeedNow(Exit.failCause(c)),
+      (a) => f(a).result,
+    );
+  };
 }

package/_src/global.ts

@@ -54,7 +54,7 @@ import { Future } from "@fncts/io/Future";
 /**
  * @tsplus global
  */
-import { Hub, PHub } from "@fncts/io/Hub/definition";
+import { Hub } from "@fncts/io/Hub/definition";
 /**
  * @tsplus global
  */
@@ -82,7 +82,7 @@ import { LogLevel } from "@fncts/io/LogLevel";
 /**
  * @tsplus global
  */
-import { PQueue, Queue } from "@fncts/io/Queue/definition";
+import { Dequeue, Enqueue,Queue } from "@fncts/io/Queue/definition";
 /**
  * @tsplus global
  */
@@ -90,7 +90,7 @@ import { Random } from "@fncts/io/Random/definition";
 /**
  * @tsplus global
  */
-import { PRef, Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref";
 /**
  * @tsplus global
  */
@@ -123,10 +123,18 @@ import { STM, USTM } from "@fncts/io/STM/definition";
  * @tsplus global
  */
 import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus global
+ */
+import { SubscriptionRef } from "@fncts/io/SubscriptionRef";
 /**
  * @tsplus global
  */
 import { Supervisor } from "@fncts/io/Supervisor/definition";
+/**
+ * @tsplus global
+ */
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
 /**
  * @tsplus global
  */

package/_src/index.ts

@@ -24,6 +24,7 @@ export type {} from "./LogSpan.js";
 export type {} from "./Queue.js";
 export type {} from "./Random.js";
 export type {} from "./Ref.js";
+export type {} from "./Reloadable.js";
 export type {} from "./RuntimeConfig.js";
 export type {} from "./Schedule.js";
 export type {} from "./Scope.js";
@@ -32,7 +33,9 @@ export type {} from "./Sink.js";
 export type {} from "./State.js";
 export type {} from "./STM.js";
 export type {} from "./Stream.js";
+export type {} from "./SubscriptionRef.js";
 export type {} from "./Supervisor.js";
+export type {} from "./SupervisorPatch.js";
 export type {} from "./TExit.js";
 export type {} from "./TFuture.js";
 export type {} from "./TReentrantLock.js";

package/_src/internal/Hub.ts

@@ -60,8 +60,7 @@ export class BoundedHubArb<A> extends Hub<A> {
     }
 
     if (this.subscriberCount !== 0) {
-      const index = this.publisherIndex % this.capacity;
-
+      const index             = this.publisherIndex % this.capacity;
       this.array[index]       = a;
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex    += 1;
@@ -100,8 +99,7 @@ export class BoundedHubArb<A> extends Hub<A> {
 
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
-      const index = this.subscribersIndex % this.capacity;
-
+      const index             = this.subscribersIndex % this.capacity;
       this.array[index]       = null as unknown as A;
       this.subscribers[index] = 0;
       this.subscribersIndex  += 1;
@@ -240,10 +238,8 @@ export class BoundedHubPow2<A> extends Hub<A> {
     }
 
     if (this.subscriberCount !== 0) {
-      const index = this.publisherIndex & this.mask;
-
-      this.array[index] = a;
-
+      const index             = this.publisherIndex & this.mask;
+      this.array[index]       = a;
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex    += 1;
     }
@@ -281,8 +277,7 @@ export class BoundedHubPow2<A> extends Hub<A> {
 
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
-      const index = this.subscribersIndex & this.mask;
-
+      const index             = this.subscribersIndex & this.mask;
       this.array[index]       = null as unknown as A;
       this.subscribers[index] = 0;
       this.subscribersIndex  += 1;
@@ -388,13 +383,11 @@ class BoundedHubPow2Subcription<A> extends SubscriptionInternal<A> {
     }
   }
 }
-
 export class BoundedHubSingle<A> extends Hub<A> {
-  publisherIndex  = 0;
-  subscriberCount = 0;
-  subscribers     = 0;
-  value: A        = null as unknown as A;
-
+  publisherIndex    = 0;
+  subscriberCount   = 0;
+  subscribers       = 0;
+  value: A          = null as unknown as A;
   readonly capacity = 1;
 
   constructor() {
@@ -468,9 +461,7 @@ class BoundedHubSingleSubscription<A> extends SubscriptionInternal<A> {
     if (this.isEmpty()) {
       return default_;
     }
-
-    const a = this.self.value;
-
+    const a                = this.self.value;
     this.self.subscribers -= 1;
 
     if (this.self.subscribers === 0) {
@@ -486,9 +477,7 @@ class BoundedHubSingleSubscription<A> extends SubscriptionInternal<A> {
     if (this.isEmpty() || n < 1) {
       return Conc.empty();
     }
-
-    const a = this.self.value;
-
+    const a                = this.self.value;
     this.self.subscribers -= 1;
 
     if (this.self.subscribers === 0) {
@@ -528,8 +517,7 @@ export class UnboundedHub<A> extends Hub<A> {
   publisherHead  = new Node<A>(null, 0, null);
   publisherIndex = 0;
   publisherTail: Node<A>;
-  subscribersIndex = 0;
-
+  subscribersIndex  = 0;
   readonly capacity = Number.MAX_SAFE_INTEGER;
 
   constructor() {
@@ -746,8 +734,10 @@ export function unsafePollAll<A>(subscription: SubscriptionInternal<A>): Conc<A>
 /**
  * Unsafely polls the specified number of values from a subscription.
  *
- * @tsplus fluent fncts.internal.Hub.Subscription unsafePollN
+ * @tsplus pipeable fncts.internal.Hub.Subscription unsafePollN
  */
-export function unsafePollN<A>(subscription: SubscriptionInternal<A>, max: number): Conc<A> {
-  return subscription.pollUpTo(max);
+export function unsafePollN(max: number) {
+  return <A>(subscription: SubscriptionInternal<A>): Conc<A> => {
+    return subscription.pollUpTo(max);
+  };
 }