@fncts/io 0.0.1

package/_src/Stream/definition.ts

@@ -0,0 +1,42 @@
+import type { _A, _E, _R } from "@fncts/base/types";
+
+export const StreamTypeId = Symbol.for("@principia/base/IO/Stream");
+export type StreamTypeId = typeof StreamTypeId;
+
+/**
+ * A `Stream<R, E, A>` is a description of a program that, when evaluated,
+ * may emit 0 or more values of type `A`, may fail with errors of type `E`
+ * and uses an environment of type `R`.
+ * One way to think of `Stream` is as a `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage buffers
+ * between operators. As an optimization `Stream` does not emit single values, but
+ * rather an array of values. This allows the cost of effect evaluation to be
+ * amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with some
+ * adjustments for the multiple-valued nature of `Stream`). These aspects allow
+ * for rich and expressive composition of streams.
+ *
+ * @tsplus type fncts.io.Stream
+ * @tsplus companion fncts.io.StreamOps
+ */
+export class Stream<R, E, A> {
+  readonly [StreamTypeId]: StreamTypeId = StreamTypeId;
+  readonly _R!: (_: R) => void;
+  readonly _E!: () => E;
+  readonly _A!: () => A;
+
+  constructor(readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>) {}
+}
+
+/**
+ * @tsplus unify fncts.io.Stream
+ */
+export function unifyStream<X extends Stream<any, any, any>>(_: X): Stream<_R<X>, _E<X>, _A<X>> {
+  return _;
+}
+
+export const DEFAULT_CHUNK_SIZE = 4096;

package/_src/Stream/internal/DebounceState.ts

@@ -0,0 +1,79 @@
+import type { HandoffSignal } from "./Handoff.js";
+
+export const enum DebounceStateTag {
+  NotStarted = "NotStarted",
+  Previous = "Previous",
+  Current = "Current",
+}
+
+export const NotStartedTag = Symbol();
+export type NotStartedTag = typeof NotStartedTag;
+export class NotStarted {
+  readonly _tag = DebounceStateTag.NotStarted;
+}
+
+export const PreviousTag = Symbol();
+export type PreviousTag = typeof PreviousTag;
+export class Previous<A> {
+  readonly _tag = DebounceStateTag.Previous;
+  constructor(readonly fiber: Fiber<never, Conc<A>>) {}
+}
+
+export const CurrentTag = Symbol();
+export type CurrentTag = typeof CurrentTag;
+export class Current<E, A> {
+  readonly _tag = DebounceStateTag.Current;
+  constructor(readonly fiber: Fiber<E, HandoffSignal<void, E, A>>) {}
+}
+
+/**
+ * @tsplus type fncts.io.Stream.DebounceState
+ */
+export type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>;
+
+/**
+ * @tsplus type fncts.io.Stream.DebounceStateOps
+ */
+export interface DebounceStateOps {}
+
+export const DebounceState: DebounceStateOps = {};
+
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps NotStarted
+ */
+export const notStarted: DebounceState<never, never> = new NotStarted();
+
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps Previous
+ */
+export function previous<A>(fiber: Fiber<never, Conc<A>>): DebounceState<never, A> {
+  return new Previous(fiber);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps Current
+ */
+export function current<E, A>(fiber: Fiber<E, HandoffSignal<void, E, A>>): DebounceState<E, A> {
+  return new Current(fiber);
+}
+
+/**
+ * @tsplus fluent 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);
+  }
+}

package/_src/Stream/internal/Handoff.ts

@@ -0,0 +1,174 @@
+import type { SinkEndReason } from "./SinkEndReason.js";
+
+import { tuple } from "@fncts/base/data/function";
+
+/**
+ * @tsplus type fncts.io.Stream.Handoff
+ * @tsplus companion fncts.io.Stream.HandoffOps
+ */
+export class Handoff<A> {
+  constructor(readonly ref: Ref<State<A>>) {}
+}
+
+export const StateTypeId = Symbol.for("fncts.io.Stream.Handoff.State");
+
+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>) {}
+}
+
+export const FullTypeId = Symbol.for("fncts.io.Stream.Handoff.State.Full");
+export class Full<A> {
+  readonly _typeId: typeof StateTypeId = StateTypeId;
+  readonly _tag: typeof FullTypeId     = FullTypeId;
+
+  constructor(readonly a: A, readonly notifyProducer: Future<never, void>) {}
+}
+
+export type State<A> = Empty | Full<A>;
+
+/**
+ * @tsplus static fncts.io.Stream.HandoffOps __call
+ */
+export function make<A>(): UIO<Handoff<A>> {
+  return Future.make<never, void>()
+    .flatMap((p) => Ref.make<State<A>>(new Empty(p)))
+    .map((refState) => new Handoff(refState));
+}
+
+/**
+ * @tsplus fluent 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,
+  );
+}
+
+/**
+ * @tsplus getter fncts.io.Stream.Handoff take
+ */
+export function take<A>(handoff: Handoff<A>): UIO<A> {
+  return Future.make<never, void>().flatMap(
+    (p) =>
+      handoff.ref.modify((s) => {
+        switch (s._tag) {
+          case FullTypeId:
+            return tuple(s.notifyProducer.succeed(undefined).as(s.a), new Empty(p));
+          case EmptyTypeId:
+            return tuple(s.notifyConsumer.await.apSecond(handoff.take), s);
+        }
+      }).flatten,
+  );
+}
+
+/**
+ * @tsplus getter fncts.io.Stream.Handoff poll
+ */
+export function poll<A>(handoff: Handoff<A>): UIO<Maybe<A>> {
+  return Future.make<never, void>().flatMap(
+    (p) =>
+      handoff.ref.modify((s) => {
+        switch (s._tag) {
+          case FullTypeId:
+            return tuple(s.notifyProducer.succeed(undefined).as(Just(s.a)), new Empty(p));
+          case EmptyTypeId:
+            return tuple(IO.succeedNow(Nothing()), s);
+        }
+      }).flatten,
+  );
+}
+
+export const HandoffSignalTypeId = Symbol.for("fncts.io.Stream.HandoffSignal");
+
+export const EmitTypeId = Symbol.for("fncts.io.Stream.HandoffSignal.Emit");
+export type EmitTypeId = typeof EmitTypeId;
+export class Emit<A> {
+  readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
+  readonly _tag: typeof EmitTypeId             = EmitTypeId;
+
+  constructor(readonly els: Conc<A>) {}
+}
+
+export const HaltTypeId = Symbol.for("fncts.io.Stream.HandoffSignal.Halt");
+export type HaltTypeId = typeof HaltTypeId;
+export class Halt<E> {
+  readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
+  readonly _tag: typeof HaltTypeId             = HaltTypeId;
+
+  constructor(readonly error: Cause<E>) {}
+}
+
+export const EndTypeId = Symbol("fncts.io.Stream.HandoffSignal.End");
+export type EndTypeId = typeof EndTypeId;
+export class End<C> {
+  readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
+  readonly _tag: typeof EndTypeId              = EndTypeId;
+
+  constructor(readonly reason: SinkEndReason<C>) {}
+}
+
+/**
+ * @tsplus type fncts.io.Stream.HandoffSignal
+ */
+export type HandoffSignal<C, E, A> = Emit<A> | Halt<E> | End<C>;
+
+/**
+ * @tsplus type fncts.io.Stream.HandoffSignalOps
+ */
+export interface HandoffSignalOps {}
+
+export const HandoffSignal: HandoffSignalOps = {};
+
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps Emit
+ */
+export function emit<A>(els: Conc<A>): HandoffSignal<never, never, A> {
+  return new Emit(els);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps Halt
+ */
+export function halt<E>(error: Cause<E>): HandoffSignal<never, E, never> {
+  return new Halt(error);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps End
+ */
+export function end<C>(reason: SinkEndReason<C>): HandoffSignal<C, never, never> {
+  return new End(reason);
+}
+
+/**
+ * @tsplus fluent fncts.io.Stream.HandoffSignal match
+ */
+export function matchSignal_<C, E, A, B, D, F>(
+  signal: HandoffSignal<C, E, A>,
+  cases: {
+    Emit: (_: Emit<A>) => B;
+    Halt: (_: Halt<E>) => D;
+    End: (_: End<C>) => 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);
+  }
+}

package/_src/Stream/internal/Pull.ts

@@ -0,0 +1,58 @@
+import type { Queue } from "../../Queue.js";
+import type { Take } from "./Take.js";
+
+export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
+
+/**
+ * @tsplus type fncts.io.Stream.PullOps
+ */
+export interface PullOps {}
+
+export const Pull: PullOps = {};
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps emit
+ */
+export function emit<A>(a: A): UIO<Conc<A>> {
+  return IO.succeedNow(Conc.single(a));
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps emitChunk
+ */
+export function emitChunk<A>(as: Conc<A>): UIO<Conc<A>> {
+  return IO.succeedNow(as);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps fromQueue
+ */
+export function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>> {
+  return d.take.flatMap((take) => take.done);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps fail
+ */
+export function fail<E>(e: E): FIO<Maybe<E>, never> {
+  return IO.failNow(Just(e));
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps failCause
+ */
+export function failCause<E>(c: Cause<E>): FIO<Maybe<E>, never> {
+  return IO.failCauseNow(c).mapError(Maybe.just);
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps empty
+ */
+export function empty<A>(): FIO<never, Conc<A>> {
+  return IO.succeedNow(Conc.empty<A>());
+}
+
+/**
+ * @tsplus static fncts.io.Stream.PullOps end
+ */
+export const end: FIO<Maybe<never>, never> = IO.failNow(Nothing());

package/_src/Stream/internal/SinkEndReason.ts

@@ -0,0 +1,59 @@
+export const enum SinkEndReasonTag {
+  SinkEnd = "SinkEnd",
+  ScheduleTimeout = "ScheduleTimeout",
+  ScheduleEnd = "ScheduleEnd",
+  UpstreamEnd = "UpstreamEnd",
+}
+
+export const SinkEndReasonTypeId = Symbol.for("fncts.io.Stream.SinkEndReason");
+
+export class SinkEnd {
+  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
+  readonly _tag = SinkEndReasonTag.SinkEnd;
+}
+
+export class ScheduleTimeout {
+  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
+  readonly _tag = SinkEndReasonTag.ScheduleTimeout;
+}
+
+export class ScheduleEnd<C> {
+  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
+  readonly _tag = SinkEndReasonTag.ScheduleEnd;
+
+  constructor(readonly c: C) {}
+}
+
+export class UpstreamEnd {
+  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
+  readonly _tag = SinkEndReasonTag.UpstreamEnd;
+}
+
+/**
+ * @tsplus type fncts.io.Stream.SinkEndReason
+ */
+export type SinkEndReason<C> = SinkEnd | ScheduleTimeout | ScheduleEnd<C> | UpstreamEnd;
+
+/**
+ * @tsplus fluent fncts.io.Stream.SinkEndReason match
+ */
+export function matchSinkEndReason_<A, B, C, D, E>(
+  self: SinkEndReason<A>,
+  cases: {
+    SinkEnd: (_: SinkEnd) => B;
+    ScheduleTimeout: (_: ScheduleTimeout) => C;
+    ScheduleEnd: (_: ScheduleEnd<A>) => D;
+    UpstreamEnd: (_: UpstreamEnd) => E;
+  },
+): B | C | D | E {
+  switch (self._tag) {
+    case SinkEndReasonTag.SinkEnd:
+      return cases.SinkEnd(self);
+    case SinkEndReasonTag.ScheduleTimeout:
+      return cases.ScheduleTimeout(self);
+    case SinkEndReasonTag.ScheduleEnd:
+      return cases.ScheduleEnd(self);
+    case SinkEndReasonTag.UpstreamEnd:
+      return cases.UpstreamEnd(self);
+  }
+}

package/_src/Stream/internal/Take.ts

@@ -0,0 +1,192 @@
+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`
+ * or an end-of-stream marker.
+ *
+ * @tsplus type fncts.io.Stream.Take
+ * @tsplus companion fncts.io.Stream.TakeOps
+ */
+export class Take<E, A> {
+  readonly _E!: () => E;
+  readonly _A!: () => A;
+
+  constructor(readonly exit: Exit<Maybe<E>, Conc<A>>) {}
+}
+
+/**
+ * Transforms `Take[E, A]` to `Effect[R, E, B]`.
+ *
+ * @tsplus getter fncts.io.Stream.Take done
+ */
+export function done<E, A>(self: Take<E, A>): FIO<Maybe<E>, Conc<A>> {
+  return IO.fromExitNow(self.exit);
+}
+
+/**
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield a value.
+ *
+ * @tsplus fluent 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);
+}
+
+/**
+ * Effectful version of `Take#fold`.
+ *
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield an effect.
+ *
+ * @tsplus fluent fncts.io.Stream.Take matchIO
+ */
+export function matchIO_<R, R1, R2, E, E1, E2, E3, A, Z>(
+  self: Take<E, A>,
+  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);
+}
+
+/**
+ * Checks if this `take` is done (`Take.end`).
+ *
+ * @tsplus getter fncts.io.Stream.Take isDone
+ */
+export function isDone<E, A>(self: Take<E, A>): boolean {
+  return self.exit.match(
+    (cause) => cause.flipCauseMaybe.isNothing(),
+    () => false,
+  );
+}
+
+/**
+ * Checks if this `take` is a failure.
+ *
+ * @tsplus getter fncts.io.Stream.Take isFailure
+ */
+export function isFailure<E, A>(self: Take<E, A>): boolean {
+  return self.exit.match(
+    (cause) => cause.flipCauseMaybe.isJust(),
+    () => false,
+  );
+}
+
+/**
+ * Checks if this `take` is a success.
+ *
+ * @tsplus getter fncts.io.Stream.Take isSuccess
+ */
+export function isSuccess<E, A>(self: Take<E, A>): boolean {
+  return self.exit.match(
+    () => false,
+    () => true,
+  );
+}
+
+/**
+ * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ *
+ * @tsplus fluent 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)));
+}
+
+/**
+ * Returns an effect that effectfully "peeks" at the success of this take.
+ *
+ * @tsplus fluent 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);
+}
+
+/**
+ * Creates a `Take<never, A>` with a singleton chunk.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps single
+ */
+export function single<A>(a: A): Take<never, A> {
+  return new Take(Exit.succeed(Conc.single(a)));
+}
+
+/**
+ * Creates a `Take[Nothing, A]` with the specified chunk.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps chunk
+ */
+export function chunk<A>(as: Conc<A>): Take<never, A> {
+  return new Take(Exit.succeed(as));
+}
+
+/**
+ * Creates a failing `Take<E, unknown>` with the specified failure.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps fail
+ */
+export function fail<E>(e: E): Take<E, never> {
+  return new Take(Exit.fail(Just(e)));
+}
+
+/**
+ * Creates an effect from `Effect<R, E,A>` that does not fail, but succeeds with the `Take<E, A>`.
+ * Error from stream when pulling is converted to `Take.halt`. Creates a singleton chunk.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps fromIO
+ */
+export function fromIO<R, E, A>(effect: IO<R, E, A>): URIO<R, Take<E, A>> {
+  return effect.matchCause((cause) => failCause(cause), single);
+}
+
+/**
+ * Creates effect from `Pull<R, E, A>` that does not fail, but succeeds with the `Take<E, A>`.
+ * Error from stream when pulling is converted to `Take.halt`, end of stream to `Take.end`.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps fromPull
+ */
+export function fromPull<R, E, A>(pull: Pull<R, E, A>): URIO<R, Take<E, A>> {
+  return pull.matchCause((cause) => cause.flipCauseMaybe.match(() => end, failCause), chunk);
+}
+
+/**
+ * Creates a failing `Take<E, never>` with the specified cause.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps failCause
+ */
+export function failCause<E>(c: Cause<E>): Take<E, never> {
+  return new Take(Exit.failCause(c.map(Maybe.just)));
+}
+
+/**
+ * Creates a failing `Take<never, never>` with the specified throwable.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps halt
+ */
+export function halt<E>(e: E): Take<never, never> {
+  return new Take(Exit.halt(e));
+}
+
+/**
+ * Creates a `Take<E, A>` from `Exit<E, A>`.
+ *
+ * @tsplus static fncts.io.Stream.TakeOps fromExit
+ */
+export function fromExit<E, A>(exit: Exit<E, A>): Take<E, A> {
+  return new Take(exit.bimap(Maybe.just, Conc.single));
+}
+
+/**
+ * End-of-stream marker
+ *
+ * @tsplus static fncts.io.Stream.TakeOps end
+ */
+export const end: Take<never, never> = new Take(Exit.fail(Nothing()));

package/_src/Stream/internal/util.ts

@@ -0,0 +1,19 @@
+import { tuple } from "@fncts/base/data/function";
+
+export function zipChunks<A, B, C>(
+  fa: Conc<A>,
+  fb: Conc<B>,
+  f: (a: A, b: B) => C,
+): readonly [Conc<C>, Either<Conc<A>, Conc<B>>] {
+  let fc    = Conc.empty<C>();
+  const len = Math.min(fa.length, fb.length);
+  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/Stream.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Stream/*.ts, exclude: ./Stream/*(DebounceState|Handoff|Pull|SinkEndReason|Take).ts }
+export * from "./Stream/api.js";
+export * from "./Stream/definition.js";
+// codegen:end

package/_src/Supervisor/api.ts

@@ -0,0 +1,36 @@
+/**
+ * @tsplus fluent 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);
+    }
+    unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>) {
+      fa.unsafeOnResume(fiber);
+      fb.unsafeOnResume(fiber);
+    }
+  })();
+}