@fncts/io 0.0.19 → 0.0.20

package/_src/Supervisor/definition.ts

@@ -1,3 +1,11 @@
+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 +30,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 +57,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 +82,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,107 @@
+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 fluent fncts.io.SupervisorPatch combine
+ */
+export function combine(first: SupervisorPatch, second: 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 fluent fncts.io.SupervisorPatch __call
+ */
+export function apply(self: SupervisorPatch, supervisor: Supervisor<any>): Supervisor<any> {
+  return applyLoop(supervisor, Cons(self));
+}

package/_src/global.ts

@@ -127,6 +127,10 @@ import { Stream } from "@fncts/io/Stream/definition";
  * @tsplus global
  */
 import { Supervisor } from "@fncts/io/Supervisor/definition";
+/**
+ * @tsplus global
+ */
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -126,6 +126,10 @@ import { Stream } from "@fncts/io/Stream/definition";
  * @tsplus global
  */
 import { Supervisor } from "@fncts/io/Supervisor/definition";
+/**
+ * @tsplus global
+ */
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "dependencies": {
-    "@fncts/base": "0.0.19",
+    "@fncts/base": "0.0.20",
     "@fncts/transformers": "0.0.2",
     "@fncts/typelevel": "0.0.14"
   },