@fncts/io 0.0.19 → 0.0.21

package/_src/Channel/core-api.ts

@@ -61,13 +61,14 @@ export function succeedNow<Z>(z: Z): Channel<never, unknown, unknown, unknown, n
  * returned channel is created by applying the specified function to the terminal value of this
  * channel.
  *
- * @tsplus fluent fncts.io.Channel map
+ * @tsplus pipeable fncts.io.Channel map
  */
-export function map_<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  f: (out: OutDone) => OutDone2,
-): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2> {
-  return self.flatMap((z) => Channel.succeedNow(f(z)));
+export function map<OutDone, OutDone2>(f: (out: OutDone) => OutDone2) {
+  return <Env, InErr, InElem, InDone, OutErr, OutElem>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2> => {
+    return self.flatMap((z) => Channel.succeedNow(f(z)));
+  };
 }
 
 /**
@@ -76,153 +77,105 @@ export function map_<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDo
  * The result is a channel that will first perform the functions of this channel, before
  * performing the functions of the created channel (including yielding its terminal value).
  *
- * @tsplus fluent fncts.io.Channel flatMap
+ * @tsplus pipeable fncts.io.Channel flatMap
  */
-export function flatMap_<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  OutElem,
-  OutDone,
-  Env1,
-  InErr1,
-  InElem1,
-  InDone1,
-  OutErr1,
-  OutElem1,
-  OutDone2,
->(
-  channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+export function flatMap<OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
   f: (d: OutDone) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>,
-): Channel<
-  Env | Env1,
-  InErr & InErr1,
-  InElem & InElem1,
-  InDone & InDone1,
-  OutErr | OutErr1,
-  OutElem | OutElem1,
-  OutDone2
-> {
-  return new Fold<
+) {
+  return <Env, InErr, InElem, InDone, OutErr, OutElem>(
+    channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<
     Env | Env1,
     InErr & InErr1,
     InElem & InElem1,
     InDone & InDone1,
     OutErr | OutErr1,
-    OutErr | OutErr1,
     OutElem | OutElem1,
-    OutDone,
     OutDone2
-  >(channel, new ContinuationK(f, Channel.failCauseNow));
+  > => {
+    return new Fold<
+      Env | Env1,
+      InErr & InErr1,
+      InElem & InElem1,
+      InDone & InDone1,
+      OutErr | OutErr1,
+      OutErr | OutErr1,
+      OutElem | OutElem1,
+      OutDone,
+      OutDone2
+    >(channel, new ContinuationK(f, Channel.failCauseNow));
+  };
 }
 
 /**
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with a tuple of the terminal values of both channels.
  *
- * @tsplus fluent fncts.io.Channel cross
+ * @tsplus pipeable fncts.io.Channel cross
  */
-export function cross_<
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
-  InElem1,
-  InDone,
-  InDone1,
-  OutErr,
-  OutErr1,
-  OutElem,
-  OutElem1,
-  OutDone,
-  OutDone1,
->(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+export function cross<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-): Channel<
-  Env | Env1,
-  InErr & InErr1,
-  InElem & InElem1,
-  InDone & InDone1,
-  OutErr | OutErr1,
-  OutElem | OutElem1,
-  readonly [OutDone, OutDone1]
-> {
-  return self.flatMap((z) => that.map((z2) => tuple(z, z2)));
+) {
+  return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<
+    Env | Env1,
+    InErr & InErr1,
+    InElem & InElem1,
+    InDone & InDone1,
+    OutErr | OutErr1,
+    OutElem | OutElem1,
+    readonly [OutDone, OutDone1]
+  > => {
+    return self.flatMap((z) => that.map((z2) => tuple(z, z2)));
+  };
 }
 
 /**
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of this channel.
  *
- * @tsplus fluent fncts.io.Channel apFirst
+ * @tsplus pipeable fncts.io.Channel apFirst
  */
-export function apFirst_<
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
-  InElem1,
-  InDone,
-  InDone1,
-  OutErr,
-  OutErr1,
-  OutElem,
-  OutElem1,
-  OutDone,
-  OutDone1,
->(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+export function apFirst<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-): Channel<
-  Env | Env1,
-  InErr & InErr1,
-  InElem & InElem1,
-  InDone & InDone1,
-  OutErr | OutErr1,
-  OutElem | OutElem1,
-  OutDone
-> {
-  return self.flatMap((a) => that.map(() => a));
+) {
+  return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<
+    Env | Env1,
+    InErr & InErr1,
+    InElem & InElem1,
+    InDone & InDone1,
+    OutErr | OutErr1,
+    OutElem | OutElem1,
+    OutDone
+  > => {
+    return self.flatMap((a) => that.map(() => a));
+  };
 }
 
 /**
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of the other channel.
  *
- * @tsplus fluent fncts.io.Channel apSecond
- * @tsplus operator fncts.io.Channel >
+ * @tsplus pipeable fncts.io.Channel apSecond
+ * @tsplus pipeable-operator fncts.io.Channel >
  */
-export function apSecond_<
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
-  InElem1,
-  InDone,
-  InDone1,
-  OutErr,
-  OutErr1,
-  OutElem,
-  OutElem1,
-  OutDone,
-  OutDone1,
->(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+export function apSecond<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
   that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-): Channel<
-  Env | Env1,
-  InErr & InErr1,
-  InElem & InElem1,
-  InDone & InDone1,
-  OutErr1 | OutErr,
-  OutElem1 | OutElem,
-  OutDone1
-> {
-  return self.flatMap(() => that);
+) {
+  return <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): Channel<
+    Env | Env1,
+    InErr & InErr1,
+    InElem & InElem1,
+    InDone & InDone1,
+    OutErr1 | OutErr,
+    OutElem1 | OutElem,
+    OutDone1
+  > => {
+    return self.flatMap(() => that);
+  };
 }

package/_src/Channel/definition.ts

@@ -41,13 +41,55 @@ export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDo
 export function unifyChannel<X extends Channel<any, any, any, any, any, any, any>>(
   _: X,
 ): Channel<
-  [X] extends [{ _Env: () => infer Env }] ? Env : never,
-  [X] extends [{ _InErr: (_: infer InErr) => void }] ? InErr : never,
-  [X] extends [{ _InElem: (_: infer InElem) => void }] ? InElem : never,
-  [X] extends [{ _InDone: (_: infer InDone) => void }] ? InDone : never,
-  [X] extends [{ _OutErr: () => infer OutErr }] ? OutErr : never,
-  [X] extends [{ _OutElem: () => infer OutElem }] ? OutElem : never,
-  [X] extends [{ _OutDone: () => infer OutDone }] ? OutDone : never
+  [X] extends [
+    {
+      _Env: () => infer Env;
+    },
+  ]
+    ? Env
+    : never,
+  [X] extends [
+    {
+      _InErr: (_: infer InErr) => void;
+    },
+  ]
+    ? InErr
+    : never,
+  [X] extends [
+    {
+      _InElem: (_: infer InElem) => void;
+    },
+  ]
+    ? InElem
+    : never,
+  [X] extends [
+    {
+      _InDone: (_: infer InDone) => void;
+    },
+  ]
+    ? InDone
+    : never,
+  [X] extends [
+    {
+      _OutErr: () => infer OutErr;
+    },
+  ]
+    ? OutErr
+    : never,
+  [X] extends [
+    {
+      _OutElem: () => infer OutElem;
+    },
+  ]
+    ? OutElem
+    : never,
+  [X] extends [
+    {
+      _OutDone: () => infer OutDone;
+    },
+  ]
+    ? OutDone
+    : never
 > {
   return _;
 }

package/_src/Channel/internal/ChannelExecutor.ts

@@ -21,9 +21,7 @@ type Finalizer<R> = (exit: Exit<unknown, unknown>) => URIO<R, unknown>;
  * SubexecutorStack
  * -------------------------------------------------------------------------------------------------
  */
-
 type Subexecutor<R> = PullFromUpstream<R> | PullFromChild<R> | DrainChildExecutors<R> | Emit<R>;
-
 const enum SubexecutorStackTag {
   PullFromUpstream = "PullFromUpstream",
   PullFromChild = "PullFromChild",
@@ -563,9 +561,7 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
       this.activeSubexecutor === null ? null : this.activeSubexecutor.close(exit);
 
     let closeSelf: URIO<Env, unknown> | null = null;
-
-    const selfFinalizers = this.popAllFinalizers(exit);
-
+    const selfFinalizers                     = this.popAllFinalizers(exit);
     if (selfFinalizers !== null) {
       closeSelf = selfFinalizers.ensuring(IO.succeed(this.clearInProgressFinalizer()));
     }

package/_src/Channel/internal/SingleProducerAsyncInput.ts

@@ -167,9 +167,7 @@ export class SingleProducerAsyncInput<Err, Elem, Done>
     (el) => Exit.succeed(el),
     (d) => Exit.fail(Either.right(d)),
   );
-
-  close = IO.fiberId.flatMap((id) => this.error(Cause.interrupt(id)));
-
+  close                = IO.fiberId.flatMap((id) => this.error(Cause.interrupt(id)));
   awaitRead: UIO<void> = this.ref.modify((s) =>
     s._stateTag === StateTag.Empty ? [s.notifyProducer.await, s] : [IO.unit, s],
   );

package/_src/Differ/api.ts

@@ -0,0 +1,72 @@
+import type { Environment } from "@fncts/base/data/Environment";
+import type { Supervisor } from "@fncts/io/Supervisor";
+
+import { SupervisorPatch } from "@fncts/io/SupervisorPatch";
+
+import { Differ } from "./definition.js";
+
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ *
+ * @tsplus static fncts.io.DifferOps update
+ */
+export function update<A>(): Differ<A, (_: A) => A> {
+  return new (class extends Differ<A, (_: A) => A> {
+    combine(first: (_: A) => A, second: (_: A) => A): (_: A) => A {
+      if (first === this.empty) return second;
+      else if (second === this.empty) return first;
+      return first.compose(second);
+    }
+    diff(oldValue: A, newValue: A): (_: A) => A {
+      if (oldValue === newValue) return this.empty;
+      else return () => newValue;
+    }
+    empty = Function.identity;
+    patch(patch: (_: A) => A): (oldValue: A) => A {
+      return patch;
+    }
+  })();
+}
+
+/**
+ * Constructs a differ that knows how to diff `Environment` values.
+ *
+ * @tsplus static fncts.io.DifferOps environment
+ */
+export function environment<A>(): Differ<Environment<A>, Environment.Patch<A, A>> {
+  return new (class extends Differ<Environment<A>, Environment.Patch<A, A>> {
+    combine(first: Environment.Patch<A, A>, second: Environment.Patch<A, A>): Environment.Patch<A, A> {
+      return first.combine(second);
+    }
+    diff(oldValue: Environment<A>, newValue: Environment<A>): Environment.Patch<A, A> {
+      return EnvironmentPatch.diff(oldValue, newValue);
+    }
+    empty = EnvironmentPatch.empty<A>();
+    patch(patch: Environment.Patch<A, A>): (oldValue: Environment<A>) => Environment<A> {
+      return (oldValue) => patch(oldValue);
+    }
+  })();
+}
+
+/**
+ * Constructs a differ that knows how to diff `Supervisor` values.
+ *
+ * @tsplus static fncts.io.DifferOps supervisor
+ */
+export function supervisor(): Differ<Supervisor<any>, Supervisor.Patch> {
+  return new (class extends Differ<Supervisor<any>, Supervisor.Patch> {
+    combine(first: SupervisorPatch, second: SupervisorPatch): SupervisorPatch {
+      return first.combine(second);
+    }
+    diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): SupervisorPatch {
+      return SupervisorPatch.diff(oldValue, newValue);
+    }
+    empty: SupervisorPatch = SupervisorPatch.empty;
+    patch(patch: SupervisorPatch): (oldValue: Supervisor<any>) => Supervisor<any> {
+      return (oldValue) => patch(oldValue);
+    }
+  })();
+}

package/_src/Differ/definition.ts

@@ -0,0 +1,16 @@
+export const DifferTypeId = Symbol.for("fncts.io.Differ");
+export type DifferTypeId = typeof DifferTypeId;
+
+/**
+ * @tsplus type fncts.io.Differ
+ * @tsplus companion fncts.io.DifferOps
+ */
+export abstract class Differ<Value, Patch> {
+  readonly _typeId: DifferTypeId = DifferTypeId;
+  declare _Value: Value;
+  declare _Patch: Patch;
+  abstract readonly empty: Patch;
+  abstract combine(first: Patch, second: Patch): Patch;
+  abstract diff(oldValue: Value, newValue: Value): Patch;
+  abstract patch(patch: Patch): (oldValue: Value) => Value;
+}

package/_src/Fiber/FiberContext.ts

@@ -192,13 +192,9 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   runUntil(maxOpCount: number): void {
     try {
       let current: Instruction | null = this.nextIO;
-
-      this.nextIO = null;
-
+      this.nextIO                     = null;
       let extraTrace: string | undefined = undefined;
-
-      const flags = this.runtimeConfig.flags;
-
+      const flags        = this.runtimeConfig.flags;
       const superviseOps =
         flags.isEnabled(RuntimeConfigFlag.SuperviseOperations) && this.currentSupervisor !== Supervisor.none;
 
@@ -277,8 +273,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                   }
                   case IOTag.Fail: {
                     const fastPathTrace: List<string> = extraTrace === undefined ? Nil() : Cons(extraTrace, Nil());
-                    extraTrace = undefined;
-
+                    extraTrace        = undefined;
                     const cause       = current.cause();
                     const tracedCause = cause.isTraced
                       ? cause
@@ -320,8 +315,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                   }
 
                   case IOTag.Async: {
-                    const trace = current.trace;
-
+                    const trace     = current.trace;
                     const epoch     = this.asyncEpoch;
                     this.asyncEpoch = epoch + 1;
 
@@ -376,17 +370,14 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     current = concrete(current.make(this.runtimeConfig, this.fiberId));
                     break;
                   }
-
                   case IOTag.Stateful: {
                     current = concrete(current.onState(this, this.state.status));
                     break;
                   }
-
                   case IOTag.Race: {
                     current = concrete(this.unsafeRace(current));
                     break;
                   }
-
                   case IOTag.Logged: {
                     this.unsafeLogWith(
                       current.message,
@@ -408,8 +399,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
               }
             } else {
               const trace = current.trace;
-
-              current = concrete(IO.failCauseNow(this.unsafeClearSuppressedCause(), trace));
+              current     = concrete(IO.failCauseNow(this.unsafeClearSuppressedCause(), trace));
               this.unsafeSetInterrupting(true);
             }
             opCount++;
@@ -677,8 +667,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
           // We are truly "done" because all the children of this fiber have terminated,
           // and there are no more pending effects that we have to execute on the fiber.
           const interruptorsCause = this.state.interruptorsCause;
-
-          const newExit = interruptorsCause.isEmpty
+          const newExit           = interruptorsCause.isEmpty
             ? exit
             : exit.mapErrorCause((cause) => {
                 if (cause.contains(interruptorsCause)) {
@@ -689,9 +678,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
               });
 
           const observers = this.state.observers;
-
-          this.state = FiberState.done(newExit);
-
+          this.state      = FiberState.done(newExit);
           this.unsafeReportUnhandled(newExit);
 
           this.unsafeNotifyObservers(newExit, observers);
@@ -799,17 +786,14 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     forkScope: Maybe<FiberScope> = Nothing(),
     trace?: string,
   ): FiberContext<any, any> {
-    const childId = FiberId.unsafeMake(TraceElement.parse(trace));
-
-    const childFiberRefLocals = this.fiberRefs.forkAs(childId).fiberRefLocals;
-
+    const childId                 = FiberId.unsafeMake(TraceElement.parse(trace));
+    const childFiberRefLocals     = this.fiberRefs.forkAs(childId).fiberRefLocals;
     const parentScope: FiberScope = forkScope
       .orElse(this.unsafeGetRef(FiberRef.forkScopeOverride))
       .getOrElse(this.scope);
 
     const grandChildren = new Set<FiberContext<any, any>>();
-
-    const childContext = new FiberContext<any, any>(
+    const childContext  = new FiberContext<any, any>(
       childId,
       this.runtimeConfig,
       Stack.single(this.unsafeIsInterruptible),
@@ -828,9 +812,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
         this.currentSupervisor.unsafeOnEnd(exit.flatten, childContext);
       });
     }
-
-    const childIO = !parentScope.unsafeAdd(childContext) ? IO.interruptAs(parentScope.fiberId) : io;
-
+    const childIO       = !parentScope.unsafeAdd(childContext) ? IO.interruptAs(parentScope.fiberId) : io;
     childContext.nextIO = concrete(childIO);
     this.unsafeGetRef(FiberRef.currentScheduler).scheduleTask(() =>
       childContext.runUntil(this.runtimeConfig.yieldOpCount),
@@ -973,10 +955,8 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     overrideValue1: unknown | null = null,
     trace?: string,
   ): void {
-    const logLevel = overrideLogLevel.getOrElse(this.unsafeGetRef(FiberRef.currentLogLevel));
-
-    const spans = this.unsafeGetRef(FiberRef.currentLogSpan);
-
+    const logLevel    = overrideLogLevel.getOrElse(this.unsafeGetRef(FiberRef.currentLogLevel));
+    const spans       = this.unsafeGetRef(FiberRef.currentLogSpan);
     const annotations = this.unsafeGetRef(FiberRef.currentLogAnnotations);
 
     let contextMap;

package/_src/Fiber/api/collectAll.ts

@@ -1,5 +1,4 @@
 import { SyntheticFiber } from "@fncts/io/Fiber/definition";
-
 /**
  * Collects all fibers into a single fiber producing an in-order list of the
  * results.
@@ -27,6 +26,6 @@ export function sequenceIterable<E, A>(
         ),
       ),
     ),
-    (fiberId) => IO.foreachDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId))
+    (fiberId) => IO.foreachDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId)),
   );
 }

package/_src/Fiber/api/evalOn.ts

@@ -1,17 +1,14 @@
 /**
- * @tsplus fluent fncts.io.Fiber evalOn
+ * @tsplus pipeable fncts.io.Fiber evalOn
  */
-export function evalOn_<E, A>(
-  fiber: Fiber<E, A>,
-  effect: UIO<any>,
-  orElse: UIO<any>,
-  __tsplusTrace?: string,
-): UIO<void> {
-  fiber.concrete();
-  switch (fiber._tag) {
-    case "RuntimeFiber":
-      return fiber.evalOn(effect, orElse);
-    case "SyntheticFiber":
-      return IO.unit;
-  }
+export function evalOn(effect: UIO<any>, orElse: UIO<any>, __tsplusTrace?: string) {
+  return <E, A>(fiber: Fiber<E, A>): UIO<void> => {
+    fiber.concrete();
+    switch (fiber._tag) {
+      case "RuntimeFiber":
+        return fiber.evalOn(effect, orElse);
+      case "SyntheticFiber":
+        return IO.unit;
+    }
+  };
 }

package/_src/Fiber/api/evalOnIO.ts

@@ -2,18 +2,15 @@
  * A fully-featured, but much slower version of `evalOn`, which is useful
  * when environment and error are required.
  *
- * @tsplus fluent fncts.io.Fiber evalOnIO
+ * @tsplus pipeable fncts.io.Fiber evalOnIO
  */
-export function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(
-  fiber: Fiber<E, A>,
-  effect: IO<R1, E1, B>,
-  orElse: IO<R2, E2, C>,
-  __tsplusTrace?: string,
-): IO<R1 | R2, E1 | E2, B | C> {
-  return Do((Δ) => {
-    const r = Δ(IO.environment<R1 & R2>());
-    const f = Δ(Future.make<E1 | E2, B | C>());
-    Δ(fiber.evalOn(f.fulfill(effect.provideEnvironment(r)), f.fulfill(orElse.provideEnvironment(r))));
-    return Δ(f.await);
-  });
+export function evalOnIO<R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string) {
+  return <E, A>(fiber: Fiber<E, A>): IO<R1 | R2, E1 | E2, B | C> => {
+    return Do((Δ) => {
+      const r = Δ(IO.environment<R1 & R2>());
+      const f = Δ(Future.make<E1 | E2, B | C>());
+      Δ(fiber.evalOn(f.fulfill(effect.provideEnvironment(r)), f.fulfill(orElse.provideEnvironment(r))));
+      return Δ(f.await);
+    });
+  };
 }

package/_src/Fiber/api/interruptAll.ts

@@ -4,9 +4,8 @@
  * @tsplus static fncts.io.FiberOps interruptAllAs
  */
 export function interruptAllAs(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void> {
-  return IO.foreachDiscard(fs, fiber => fiber.interruptAsFork(id)) > IO.foreachDiscard(fs, fiber => fiber.await)
+  return IO.foreachDiscard(fs, (fiber) => fiber.interruptAsFork(id)) > IO.foreachDiscard(fs, (fiber) => fiber.await);
 }
-
 /**
  * Interrupts all fibers and awaits their interruption
  *

package/_src/Fiber/api/interruptAs.ts

@@ -1,7 +1,9 @@
 /**
- * @tsplus fluent fncts.io.Fiber interruptAs
+ * @tsplus pipeable fncts.io.Fiber interruptAs
  */
-export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>> {
-  self.concrete();
-  return self.interruptAsFork(fiberId) > self.await;
+export function interruptAs(fiberId: FiberId, __tsplusTrace?: string) {
+  return <E, A>(self: Fiber<E, A>): UIO<Exit<E, A>> => {
+    self.concrete();
+    return self.interruptAsFork(fiberId) > self.await;
+  };
 }

package/_src/Fiber/api/interruptAsFork.ts

@@ -1,7 +1,9 @@
 /**
- * @tsplus fluent fncts.io.Fiber interruptAsFork
+ * @tsplus pipeable fncts.io.Fiber interruptAsFork
  */
-export function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<void> {
-  self.concrete();
-  return self.interruptAsFork(fiberId);
+export function interruptAsFork(fiberId: FiberId) {
+  return <E, A>(self: Fiber<E, A>): UIO<void> => {
+    self.concrete();
+    return self.interruptAsFork(fiberId);
+  };
 }