@fncts/io 0.0.20 → 0.0.21

package/_src/Stream/definition.ts

@@ -1,5 +1,4 @@
 import type { _A, _E, _R } from "@fncts/base/types";
-
 export const StreamTypeId = Symbol.for("@principia/base/IO/Stream");
 export type StreamTypeId = typeof StreamTypeId;
 
@@ -28,7 +27,6 @@ export class Stream<R, E, A> {
   declare _R: () => R;
   declare _E: () => E;
   declare _A: () => A;
-
   constructor(readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>) {}
 }
 

package/_src/Stream/internal/DebounceState.ts

@@ -58,22 +58,21 @@ export function current<E, A>(fiber: Fiber<E, HandoffSignal<E, A>>): DebounceSta
 }
 
 /**
- * @tsplus fluent fncts.io.Stream.DebounceState match
+ * @tsplus pipeable fncts.io.Stream.DebounceState match
  */
-export function match_<E, A, B, C, D>(
-  ds: DebounceState<E, A>,
-  cases: {
-    NotStarted: (_: NotStarted) => B;
-    Current: (_: Current<E, A>) => C;
-    Previous: (_: Previous<A>) => D;
-  },
-): B | C | D {
-  switch (ds._tag) {
-    case DebounceStateTag.NotStarted:
-      return cases.NotStarted(ds);
-    case DebounceStateTag.Current:
-      return cases.Current(ds);
-    case DebounceStateTag.Previous:
-      return cases.Previous(ds);
-  }
+export function match<E, A, B, C, D>(cases: {
+  NotStarted: (_: NotStarted) => B;
+  Current: (_: Current<E, A>) => C;
+  Previous: (_: Previous<A>) => D;
+}) {
+  return (ds: DebounceState<E, A>): B | C | D => {
+    switch (ds._tag) {
+      case DebounceStateTag.NotStarted:
+        return cases.NotStarted(ds);
+      case DebounceStateTag.Current:
+        return cases.Current(ds);
+      case DebounceStateTag.Previous:
+        return cases.Previous(ds);
+    }
+  };
 }

package/_src/Stream/internal/Handoff.ts

@@ -16,7 +16,6 @@ export const EmptyTypeId = Symbol.for("fncts.io.Stream.Handoff.State.Empty");
 export class Empty {
   readonly _typeId: typeof StateTypeId = StateTypeId;
   readonly _tag: typeof EmptyTypeId    = EmptyTypeId;
-
   constructor(readonly notifyConsumer: Future<never, void>) {}
 }
 
@@ -40,20 +39,22 @@ export function make<A>(): UIO<Handoff<A>> {
 }
 
 /**
- * @tsplus fluent fncts.io.Stream.Handoff offer
+ * @tsplus pipeable fncts.io.Stream.Handoff offer
  */
-export function offer<A>(handoff: Handoff<A>, a: A): UIO<void> {
-  return Future.make<never, void>().flatMap(
-    (p) =>
-      handoff.ref.modify((s) => {
-        switch (s._tag) {
-          case FullTypeId:
-            return tuple(s.notifyProducer.await.apSecond(handoff.offer(a)), s);
-          case EmptyTypeId:
-            return tuple(s.notifyConsumer.succeed(undefined).apSecond(p.await), new Full(a, p));
-        }
-      }).flatten,
-  );
+export function offer<A>(a: A) {
+  return (handoff: Handoff<A>): UIO<void> => {
+    return Future.make<never, void>().flatMap(
+      (p) =>
+        handoff.ref.modify((s) => {
+          switch (s._tag) {
+            case FullTypeId:
+              return tuple(s.notifyProducer.await.apSecond(handoff.offer(a)), s);
+            case EmptyTypeId:
+              return tuple(s.notifyConsumer.succeed(undefined).apSecond(p.await), new Full(a, p));
+          }
+        }).flatten,
+    );
+  };
 }
 
 /**
@@ -97,7 +98,6 @@ export type EmitTypeId = typeof EmitTypeId;
 export class Emit<A> {
   readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
   readonly _tag: typeof EmitTypeId             = EmitTypeId;
-
   constructor(readonly els: Conc<A>) {}
 }
 
@@ -106,7 +106,6 @@ export type HaltTypeId = typeof HaltTypeId;
 export class Halt<E> {
   readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
   readonly _tag: typeof HaltTypeId             = HaltTypeId;
-
   constructor(readonly error: Cause<E>) {}
 }
 
@@ -115,7 +114,6 @@ export type EndTypeId = typeof EndTypeId;
 export class End {
   readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
   readonly _tag: typeof EndTypeId              = EndTypeId;
-
   constructor(readonly reason: SinkEndReason) {}
 }
 
@@ -128,7 +126,6 @@ export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End;
  * @tsplus type fncts.io.Stream.HandoffSignalOps
  */
 export interface HandoffSignalOps {}
-
 export const HandoffSignal: HandoffSignalOps = {};
 
 /**
@@ -153,22 +150,21 @@ export function end<C>(reason: SinkEndReason): HandoffSignal<never, never> {
 }
 
 /**
- * @tsplus fluent fncts.io.Stream.HandoffSignal match
+ * @tsplus pipeable fncts.io.Stream.HandoffSignal match
  */
-export function matchSignal_<E, A, B, D, F>(
-  signal: HandoffSignal<E, A>,
-  cases: {
-    Emit: (_: Emit<A>) => B;
-    Halt: (_: Halt<E>) => D;
-    End: (_: End) => F;
-  },
-): B | D | F {
-  switch (signal._tag) {
-    case EmitTypeId:
-      return cases.Emit(signal);
-    case HaltTypeId:
-      return cases.Halt(signal);
-    case EndTypeId:
-      return cases.End(signal);
-  }
+export function matchSignal<E, A, B, D, F>(cases: {
+  Emit: (_: Emit<A>) => B;
+  Halt: (_: Halt<E>) => D;
+  End: (_: End) => F;
+}) {
+  return (signal: HandoffSignal<E, A>): B | D | F => {
+    switch (signal._tag) {
+      case EmitTypeId:
+        return cases.Emit(signal);
+      case HaltTypeId:
+        return cases.Halt(signal);
+      case EndTypeId:
+        return cases.End(signal);
+    }
+  };
 }

package/_src/Stream/internal/Pull.ts

@@ -1,4 +1,3 @@
-import type { Queue } from "../../Queue.js";
 import type { Take } from "./Take.js";
 
 export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
@@ -27,7 +26,7 @@ export function emitChunk<A>(as: Conc<A>): UIO<Conc<A>> {
 /**
  * @tsplus static fncts.io.Stream.PullOps fromQueue
  */
-export function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>> {
+export function fromQueue<E, A>(d: Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>> {
   return d.take.flatMap((take) => take.done);
 }
 

package/_src/Stream/internal/SinkEndReason.ts

@@ -23,19 +23,18 @@ export class UpstreamEnd {
 export type SinkEndReason = ScheduleEnd | UpstreamEnd;
 
 /**
- * @tsplus fluent fncts.io.Stream.SinkEndReason match
+ * @tsplus pipeable fncts.io.Stream.SinkEndReason match
  */
-export function matchSinkEndReason_<A, B>(
-  self: SinkEndReason,
-  cases: {
-    ScheduleEnd: (_: ScheduleEnd) => A;
-    UpstreamEnd: (_: UpstreamEnd) => B;
-  },
-): A | B {
-  switch (self._tag) {
-    case SinkEndReasonTag.ScheduleEnd:
-      return cases.ScheduleEnd(self);
-    case SinkEndReasonTag.UpstreamEnd:
-      return cases.UpstreamEnd(self);
-  }
+export function matchSinkEndReason<A, B>(cases: {
+  ScheduleEnd: (_: ScheduleEnd) => A;
+  UpstreamEnd: (_: UpstreamEnd) => B;
+}) {
+  return (self: SinkEndReason): A | B => {
+    switch (self._tag) {
+      case SinkEndReasonTag.ScheduleEnd:
+        return cases.ScheduleEnd(self);
+      case SinkEndReasonTag.UpstreamEnd:
+        return cases.UpstreamEnd(self);
+    }
+  };
 }

package/_src/Stream/internal/Take.ts

@@ -1,5 +1,4 @@
 import type { Pull } from "./Pull.js";
-
 /**
  * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
  * values. A `Take` may be a failure cause `Cause<E>`, an chunk value `A`
@@ -11,7 +10,6 @@ import type { Pull } from "./Pull.js";
 export class Take<E, A> {
   readonly _E!: () => E;
   readonly _A!: () => A;
-
   constructor(readonly exit: Exit<Maybe<E>, Conc<A>>) {}
 }
 
@@ -28,15 +26,12 @@ export function done<E, A>(self: Take<E, A>): FIO<Maybe<E>, Conc<A>> {
  * Folds over the failure cause, success value and end-of-stream marker to
  * yield a value.
  *
- * @tsplus fluent fncts.io.Stream.Take match
+ * @tsplus pipeable fncts.io.Stream.Take match
  */
-export function match_<E, A, Z>(
-  self: Take<E, A>,
-  end: Z,
-  error: (cause: Cause<E>) => Z,
-  value: (chunk: Conc<A>) => Z,
-): Z {
-  return self.exit.match((cause) => cause.flipCauseMaybe.match(() => end, error), value);
+export function match<E, A, Z>(end: Z, error: (cause: Cause<E>) => Z, value: (chunk: Conc<A>) => Z) {
+  return (self: Take<E, A>): Z => {
+    return self.exit.match((cause) => cause.flipCauseMaybe.match(() => end, error), value);
+  };
 }
 
 /**
@@ -45,15 +40,16 @@ export function match_<E, A, Z>(
  * Folds over the failure cause, success value and end-of-stream marker to
  * yield an effect.
  *
- * @tsplus fluent fncts.io.Stream.Take matchIO
+ * @tsplus pipeable fncts.io.Stream.Take matchIO
  */
-export function matchIO_<R, R1, R2, E, E1, E2, E3, A, Z>(
-  self: Take<E, A>,
+export function matchIO<R, R1, R2, E, E1, E2, E3, A, Z>(
   end: IO<R, E1, Z>,
   error: (cause: Cause<E>) => IO<R1, E2, Z>,
   value: (chunk: Conc<A>) => IO<R2, E3, Z>,
-): IO<R | R1 | R2, E1 | E2 | E3, Z> {
-  return self.exit.match((cause) => cause.flipCauseMaybe.match(() => end, error), value);
+) {
+  return (self: Take<E, A>): IO<R | R1 | R2, E1 | E2 | E3, Z> => {
+    return self.exit.match((cause) => cause.flipCauseMaybe.match(() => end, error), value);
+  };
 }
 
 /**
@@ -95,19 +91,23 @@ export function isSuccess<E, A>(self: Take<E, A>): boolean {
 /**
  * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
  *
- * @tsplus fluent fncts.io.Stream.Take map
+ * @tsplus pipeable fncts.io.Stream.Take map
  */
-export function map_<E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B> {
-  return new Take(self.exit.map((chunk) => chunk.map(f)));
+export function map<A, B>(f: (a: A) => B) {
+  return <E>(self: Take<E, A>): Take<E, B> => {
+    return new Take(self.exit.map((chunk) => chunk.map(f)));
+  };
 }
 
 /**
  * Returns an effect that effectfully "peeks" at the success of this take.
  *
- * @tsplus fluent fncts.io.Stream.Take tap
+ * @tsplus pipeable fncts.io.Stream.Take tap
  */
-export function tap_<R, E, E1, A>(self: Take<E, A>, f: (chunk: Conc<A>) => IO<R, E1, any>): IO<R, E1, void> {
-  return self.exit.foreachIO(f);
+export function tap<R, E1, A>(f: (chunk: Conc<A>) => IO<R, E1, any>) {
+  return <E>(self: Take<E, A>): IO<R, E1, void> => {
+    return self.exit.foreachIO(f);
+  };
 }
 
 /**

package/_src/Stream/internal/util.ts

@@ -10,10 +10,8 @@ export function zipChunks<A, B, C>(
   for (let i = 0; i < len; i++) {
     fc = fc.append(f(fa.unsafeGet(i), fb.unsafeGet(i)));
   }
-
   if (fa.length > fb.length) {
     return tuple(fc, Either.left(fa.drop(fb.length)));
   }
-
   return tuple(fc, Either.right(fb.drop(fa.length)));
 }

package/_src/SubscriptionRef.ts

@@ -0,0 +1,44 @@
+import { Synchronized } from "@fncts/io/Ref";
+import { Stream } from "@fncts/io/Stream";
+
+export const SubscriptionRefTypeId = Symbol.for("fncts.io.SubscriptionRef");
+export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
+
+/**
+ * @tsplus type fncts.io.SubscriptionRef
+ * @tsplus companion fncts.io.SubscriptionRefOps
+ */
+export class SubscriptionRef<A> extends Synchronized<A> {
+  readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId = SubscriptionRefTypeId;
+  constructor(readonly semaphore: TSemaphore, readonly hub: Hub<A>, readonly ref: Ref<A>) {
+    super(semaphore, ref.get, (a) => ref.set(a));
+  }
+  changes: Stream<never, never, A> = Stream.unwrapScoped(
+    this.withPermit(
+      this.unsafeGet.flatMap((a) =>
+        Stream.fromHubScoped(this.hub).map((stream) => Stream.succeedNow(a).concat(stream)),
+      ),
+    ),
+  );
+  set(a: A, __tsplusTrace?: string): UIO<void> {
+    return this.withPermit(this.unsafeSet(a) < this.hub.publish(a));
+  }
+  modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1, B> {
+    return this.withPermit(
+      this.unsafeGet.flatMap(f).flatMap(([b, a]) => this.unsafeSet(a).as(b) < this.hub.publish(a)),
+    );
+  }
+}
+
+/**
+ * @tsplus static fncts.io.SubscriptionRefOps make
+ * @tsplus static fncts.io.SubscriptionRefOps __call
+ */
+export function make<A>(value: Lazy<A>): UIO<SubscriptionRef<A>> {
+  return Do((Δ) => {
+    const semaphore = Δ(TSemaphore.make(1).commit);
+    const hub       = Δ(Hub.makeUnbounded<A>());
+    const ref       = Δ(Ref.make(value));
+    return new SubscriptionRef(semaphore, hub, ref);
+  });
+}

package/_src/Supervisor/api.ts

@@ -1,10 +1,12 @@
 import { concrete, SupervisorTag, Zip } from "@fncts/io/Supervisor/definition";
 
 /**
- * @tsplus fluent fncts.io.Supervisor zip
+ * @tsplus pipeable fncts.io.Supervisor zip
  */
-export function zip_<A, B>(fa: Supervisor<A>, fb: Supervisor<B>): Supervisor<readonly [A, B]> {
-  return new Zip(fa, fb);
+export function zip<B>(fb: Supervisor<B>) {
+  return <A>(fa: Supervisor<A>): Supervisor<readonly [A, B]> => {
+    return new Zip(fa, fb);
+  };
 }
 
 /**
@@ -24,17 +26,19 @@ export function toSet(self: Supervisor<any>): HashSet<Supervisor<any>> {
 }
 
 /**
- * @tsplus fluent fncts.io.Supervisor removeSupervisor
+ * @tsplus pipeable fncts.io.Supervisor removeSupervisor
  */
-export function removeSupervisor(self: Supervisor<any>, that: Supervisor<any>): Supervisor<any> {
-  concrete(self);
-  if (self === that) return Supervisor.none;
-  else {
-    switch (self._tag) {
-      case SupervisorTag.Zip:
-        return self.first.removeSupervisor(that).zip(self.second.removeSupervisor(that));
-      default:
-        return self;
+export function removeSupervisor(that: Supervisor<any>) {
+  return (self: Supervisor<any>): Supervisor<any> => {
+    concrete(self);
+    if (self === that) return Supervisor.none;
+    else {
+      switch (self._tag) {
+        case SupervisorTag.Zip:
+          return self.first.removeSupervisor(that).zip(self.second.removeSupervisor(that));
+        default:
+          return self;
+      }
     }
-  }
+  };
 }

package/_src/Supervisor/definition.ts

@@ -1,5 +1,4 @@
 import type { SupervisorPatch } from "@fncts/io/SupervisorPatch";
-
 export const enum SupervisorTag {
   Const,
   Proxy,

package/_src/SupervisorPatch.ts

@@ -56,10 +56,12 @@ export function concrete(_: SupervisorPatch): asserts _ is Concrete {
 export const empty: SupervisorPatch = new Empty();
 
 /**
- * @tsplus fluent fncts.io.SupervisorPatch combine
+ * @tsplus pipeable fncts.io.SupervisorPatch combine
  */
-export function combine(first: SupervisorPatch, second: SupervisorPatch): SupervisorPatch {
-  return new Combine(first, second);
+export function combine(second: SupervisorPatch) {
+  return (first: SupervisorPatch): SupervisorPatch => {
+    return new Combine(first, second);
+  };
 }
 
 /**
@@ -100,8 +102,10 @@ function applyLoop(supervisor: Supervisor<any>, patches: List<SupervisorPatch>):
 }
 
 /**
- * @tsplus fluent fncts.io.SupervisorPatch __call
+ * @tsplus pipeable fncts.io.SupervisorPatch __call
  */
-export function apply(self: SupervisorPatch, supervisor: Supervisor<any>): Supervisor<any> {
-  return applyLoop(supervisor, Cons(self));
+export function apply(supervisor: Supervisor<any>) {
+  return (self: SupervisorPatch): Supervisor<any> => {
+    return applyLoop(supervisor, Cons(self));
+  };
 }

package/_src/TExit/definition.ts

@@ -40,11 +40,9 @@ export class Fail<E> {
   readonly _typeId: TExitTypeId = TExitTypeId;
   readonly _tag                 = TExitTag.Fail;
   constructor(readonly value: E) {}
-
   get [Symbol.hash](): number {
     return Hashable.combine(_failHash, Hashable.unknown(this.value));
   }
-
   [Symbol.equals](that: unknown): boolean {
     return isTExit(that) && isFail(that) && Equatable.strictEquals(this.value, that.value);
   }
@@ -63,11 +61,9 @@ export class Succeed<A> {
   readonly _typeId: TExitTypeId = TExitTypeId;
   readonly _tag                 = TExitTag.Succeed;
   constructor(readonly value: A) {}
-
   get [Symbol.hash](): number {
     return P.Hashable.combine(_succeedHash, Hashable.unknown(this.value));
   }
-
   [Symbol.equals](that: unknown): boolean {
     return isTExit(that) && isSucceed(that) && P.Equatable.strictEquals(this.value, that.value);
   }
@@ -86,11 +82,9 @@ export class Halt {
   readonly _typeId: TExitTypeId = TExitTypeId;
   readonly _tag                 = TExitTag.Halt;
   constructor(readonly value: unknown) {}
-
   get [Symbol.hash](): number {
     return Hashable.combine(_haltHash, Hashable.unknown(this.value));
   }
-
   [Symbol.equals](that: unknown): boolean {
     return isTExit(that) && isHalt(that) && P.Equatable.strictEquals(this.value, that.value);
   }
@@ -109,11 +103,9 @@ export class Interrupt {
   readonly _typeId = TExitTypeId;
   readonly _tag    = TExitTag.Interrupt;
   constructor(readonly fiberId: FiberId) {}
-
   get [Symbol.hash](): number {
     return Hashable.combine(_interruptHash, Hashable.unknown(this.fiberId));
   }
-
   [Symbol.equals](that: unknown): boolean {
     return isTExit(that) && isInterrupt(that) && P.Equatable.strictEquals(this.fiberId, that.fiberId);
   }

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;