@fncts/io 0.0.19 → 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,36 +1,44 @@
+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 (class extends Supervisor<readonly [A, B]> {
-    value = fa.value.zip(fb.value);
-    unsafeOnStart<R, E, A>(
-      environment: Environment<R>,
-      effect: IO<R, E, A>,
-      parent: Maybe<Fiber.Runtime<any, any>>,
-      fiber: Fiber.Runtime<E, A>,
-    ) {
-      try {
-        fa.unsafeOnStart(environment, effect, parent, fiber);
-      } finally {
-        fb.unsafeOnStart(environment, effect, parent, fiber);
-      }
-    }
-    unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>) {
-      fa.unsafeOnEnd(value, fiber);
-      fb.unsafeOnEnd(value, fiber);
-    }
-    unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>) {
-      fa.unsafeOnEffect(fiber, effect);
-      fb.unsafeOnEffect(fiber, effect);
-    }
-    unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>) {
-      fa.unsafeOnSuspend(fiber);
-      fb.unsafeOnSuspend(fiber);
+export function zip<B>(fb: Supervisor<B>) {
+  return <A>(fa: Supervisor<A>): Supervisor<readonly [A, B]> => {
+    return new Zip(fa, fb);
+  };
+}
+
+/**
+ * @tsplus getter fncts.io.Supervisor toSet
+ */
+export function toSet(self: Supervisor<any>): HashSet<Supervisor<any>> {
+  concrete(self);
+  if (self === Supervisor.none) return HashSet.makeDefault();
+  else {
+    switch (self._tag) {
+      case SupervisorTag.Zip:
+        return self.first.toSet.union(self.second.toSet);
+      default:
+        return HashSet.makeDefault<Supervisor<any>>().add(self);
     }
-    unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>) {
-      fa.unsafeOnResume(fiber);
-      fb.unsafeOnResume(fiber);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.io.Supervisor removeSupervisor
+ */
+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,3 +1,10 @@
+import type { SupervisorPatch } from "@fncts/io/SupervisorPatch";
+export const enum SupervisorTag {
+  Const,
+  Proxy,
+  Zip,
+}
+
 /**
  * @tsplus type fncts.io.Supervisor
  * @tsplus companion fncts.io.SupervisorOps
@@ -22,7 +29,12 @@ export abstract class Supervisor<A> {
   }
 }
 
+export declare namespace Supervisor {
+  type Patch = SupervisorPatch;
+}
+
 export class ConstSupervisor<A> extends Supervisor<A> {
+  readonly _tag = SupervisorTag.Const;
   constructor(readonly value: UIO<A>) {
     super();
   }
@@ -44,6 +56,7 @@ export class ConstSupervisor<A> extends Supervisor<A> {
 }
 
 export class ProxySupervisor<A> extends Supervisor<A> {
+  readonly _tag = SupervisorTag.Proxy;
   constructor(readonly value: UIO<A>, readonly underlying: Supervisor<any>) {
     super();
   }
@@ -68,3 +81,48 @@ export class ProxySupervisor<A> extends Supervisor<A> {
     this.underlying.unsafeOnResume(fiber);
   }
 }
+
+export class Zip<A, B> extends Supervisor<readonly [A, B]> {
+  readonly _tag = SupervisorTag.Zip;
+  constructor(readonly first: Supervisor<A>, readonly second: Supervisor<B>) {
+    super();
+  }
+  value = this.first.value.zip(this.second.value);
+  unsafeOnStart<R, E, A>(
+    environment: Environment<R>,
+    effect: IO<R, E, A>,
+    parent: Maybe<Fiber.Runtime<any, any>>,
+    fiber: Fiber.Runtime<E, A>,
+  ) {
+    try {
+      this.first.unsafeOnStart(environment, effect, parent, fiber);
+    } finally {
+      this.second.unsafeOnStart(environment, effect, parent, fiber);
+    }
+  }
+  unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>) {
+    this.first.unsafeOnEnd(value, fiber);
+    this.second.unsafeOnEnd(value, fiber);
+  }
+  unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>) {
+    this.first.unsafeOnEffect(fiber, effect);
+    this.second.unsafeOnEffect(fiber, effect);
+  }
+  unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>) {
+    this.first.unsafeOnSuspend(fiber);
+    this.second.unsafeOnSuspend(fiber);
+  }
+  unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>) {
+    this.first.unsafeOnResume(fiber);
+    this.second.unsafeOnResume(fiber);
+  }
+}
+
+export type Concrete = ConstSupervisor<any> | ProxySupervisor<any> | Zip<any, any>;
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete(_: Supervisor<any>): asserts _ is Concrete {
+  //
+}

package/_src/SupervisorPatch.ts

@@ -0,0 +1,111 @@
+export const SupervisorPatchTypeId = Symbol.for("fncts.io.Supervisor.Patch");
+export type SupervisorPatchTypeId = typeof SupervisorPatchTypeId;
+
+export const enum SupervisorPatchTag {
+  AddSupervisor,
+  Combine,
+  Empty,
+  RemoveSupervisor,
+}
+
+/**
+ * @tsplus type fncts.io.SupervisorPatch
+ * @tsplus companion fncts.io.SupervisorPatchOps
+ */
+export abstract class SupervisorPatch {
+  readonly _typeId: SupervisorPatchTypeId = SupervisorPatchTypeId;
+}
+
+export class AddSupervisor extends SupervisorPatch {
+  readonly _tag = SupervisorPatchTag.AddSupervisor;
+  constructor(readonly supervisor: Supervisor<any>) {
+    super();
+  }
+}
+
+export class Combine extends SupervisorPatch {
+  readonly _tag = SupervisorPatchTag.Combine;
+  constructor(readonly first: SupervisorPatch, readonly second: SupervisorPatch) {
+    super();
+  }
+}
+
+export class Empty extends SupervisorPatch {
+  readonly _tag = SupervisorPatchTag.Empty;
+}
+
+export class RemoveSupervisor extends SupervisorPatch {
+  readonly _tag = SupervisorPatchTag.RemoveSupervisor;
+  constructor(readonly supervisor: Supervisor<any>) {
+    super();
+  }
+}
+
+export type Concrete = AddSupervisor | Combine | Empty | RemoveSupervisor;
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete(_: SupervisorPatch): asserts _ is Concrete {
+  //
+}
+
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps empty
+ */
+export const empty: SupervisorPatch = new Empty();
+
+/**
+ * @tsplus pipeable fncts.io.SupervisorPatch combine
+ */
+export function combine(second: SupervisorPatch) {
+  return (first: SupervisorPatch): SupervisorPatch => {
+    return new Combine(first, second);
+  };
+}
+
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps diff
+ */
+export function diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): SupervisorPatch {
+  if (oldValue === newValue) return new Empty();
+  else {
+    const oldSupervisors = oldValue.toSet;
+    const newSupervisors = newValue.toSet;
+    const added          = newSupervisors
+      .difference(oldSupervisors)
+      .foldLeft(SupervisorPatch.empty, (patch, supervisor) => patch.combine(new AddSupervisor(supervisor)));
+    const removed = oldSupervisors
+      .difference(newSupervisors)
+      .foldLeft(SupervisorPatch.empty, (patch, supervisor) => patch.combine(new RemoveSupervisor(supervisor)));
+    return added.combine(removed);
+  }
+}
+
+function applyLoop(supervisor: Supervisor<any>, patches: List<SupervisorPatch>): Supervisor<any> {
+  if (patches.isEmpty()) {
+    return supervisor;
+  }
+  const head = patches.head;
+  const tail = patches.tail;
+  concrete(head);
+  switch (head._tag) {
+    case SupervisorPatchTag.AddSupervisor:
+      return applyLoop(supervisor.zip(head.supervisor), tail);
+    case SupervisorPatchTag.Combine:
+      return applyLoop(supervisor, Cons(head.first, Cons(head.second, patches)));
+    case SupervisorPatchTag.Empty:
+      return applyLoop(supervisor, tail);
+    case SupervisorPatchTag.RemoveSupervisor:
+      return applyLoop(supervisor.removeSupervisor(head.supervisor), tail);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.io.SupervisorPatch __call
+ */
+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);
   }