@fncts/io 0.0.20 → 0.0.21

package/_src/Fiber/api/zipWith.ts

@@ -5,22 +5,19 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
  * the specified combiner function. Both joins and interruptions are performed
  * in sequential order from left to right.
  *
- * @tsplus fluent fncts.io.Fiber zipWith
+ * @tsplus pipeable fncts.io.Fiber zipWith
  */
-export function zipWith_<E, A, E1, B, C>(
-  self: Fiber<E, A>,
-  that: Fiber<E1, B>,
-  f: (a: A, b: B) => C,
-  __tsplusTrace?: string,
-): Fiber<E | E1, C> {
-  return new SyntheticFiber(
-    self.id,
-    self.await.flatMap(IO.fromExitNow).zipWithC(that.await.flatMap(IO.fromExitNow), f).result,
-    self.children,
-    that.inheritRefs > self.inheritRefs,
-    self.poll.zipWith(that.poll, (ma, mb) =>
-      ma.isJust() && mb.isJust() ? Just(ma.value.zipWithCause(mb.value, f, Cause.then)) : Nothing(),
-    ),
-    (id) => self.interruptAs(id).zipWith(that.interruptAs(id), (ea, eb) => ea.zipWithCause(eb, f, Cause.then)),
-  );
+export function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <E>(self: Fiber<E, A>): Fiber<E | E1, C> => {
+    return new SyntheticFiber(
+      self.id,
+      self.await.flatMap(IO.fromExitNow).zipWithC(that.await.flatMap(IO.fromExitNow), f).result,
+      self.children,
+      that.inheritRefs > self.inheritRefs,
+      self.poll.zipWith(that.poll, (ma, mb) =>
+        ma.isJust() && mb.isJust() ? Just(ma.value.zipWithCause(mb.value, f, Cause.then)) : Nothing(),
+      ),
+      (id) => self.interruptAs(id).zipWith(that.interruptAs(id), (ea, eb) => ea.zipWithCause(eb, f, Cause.then)),
+    );
+  };
 }

package/_src/Fiber/definition.ts

@@ -11,7 +11,6 @@ export interface Fiber<E, A> {
   readonly _E: () => E;
   readonly _A: () => A;
 }
-
 /**
  * @tsplus type fncts.io.FiberOps
  */
@@ -26,29 +25,24 @@ export declare namespace Fiber {
 
 export interface FiberCommon<E, A> extends Fiber<E, A> {
   readonly id: FiberId;
-
   /**
    * Awaits the fiber, which suspends the awaiting fiber until the result of the
    * fiber has been determined.
    */
   readonly await: UIO<Exit<E, A>>;
-
   /**
    * Inherits values from all {@link FiberRef} instances into current fiber.
    * This will resume immediately.
    */
   readonly inheritRefs: UIO<void>;
-
   /**
    * Interrupts the fiber as if interrupted from the specified fiber.
    */
   readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
-
   /**
    * Tentatively observes the fiber, but returns immediately if it is not already done.
    */
   readonly poll: UIO<Maybe<Exit<E, A>>>;
-
   /**
    * Retrieves the immediate children of the fiber.
    */
@@ -57,34 +51,28 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
 
 export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
   readonly _tag: "RuntimeFiber";
-
   /**
    * The identity of the Fiber
    */
   readonly id: FiberId.Runtime;
-
   /**
    * The location the fiber was forked from
    */
   readonly location: TraceElement;
-
   /**
    * Evaluates the specified effect on the fiber. If this is not possible,
    * because the fiber has already ended life, then the specified alternate
    * effect will be executed instead.
    */
   readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
-
   readonly evalOnIO: <R1, E1, B, R2, E2, C>(
     effect: IO<R1, E1, B>,
     orElse: IO<R2, E2, C>,
   ) => IO<R1 | R2, E1 | E2, B | C>;
-
   /**
    * The status of the fiber.
    */
   readonly status: UIO<FiberStatus>;
-
   /**
    * The trace of the Fiber
    */
@@ -92,13 +80,11 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
 }
 
 export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
-  readonly _tag = "SyntheticFiber";
-
+  readonly _tag                 = "SyntheticFiber";
   readonly _typeId: FiberTypeId = FiberTypeId;
   readonly _E!: () => E;
   readonly _A!: () => A;
   readonly await;
-
   constructor(
     readonly id: FiberId,
     wait: UIO<Exit<E, A>>,

package/_src/Fiber.ts

@@ -3,7 +3,6 @@ export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
 export * from "./Fiber/FiberContext.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: Fiber/api/*.ts }
 export * from "./Fiber/api/await.js";
 export * from "./Fiber/api/awaitAll.js";
@@ -17,6 +16,7 @@ export * from "./Fiber/api/inheritRefs.js";
 export * from "./Fiber/api/interrupt.js";
 export * from "./Fiber/api/interruptAll.js";
 export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptAsFork.js";
 export * from "./Fiber/api/interruptFork.js";
 export * from "./Fiber/api/join.js";
 export * from "./Fiber/api/joinAll.js";

package/_src/FiberRef/api/locallyScoped.ts

@@ -1,9 +1,11 @@
 /**
- * @tsplus fluent fncts.io.FiberRef locallyScoped
+ * @tsplus pipeable fncts.io.FiberRef locallyScoped
  */
-export function locallyScoped_<A>(ref: FiberRef<A>, a: A, __tsplusTrace?: string): IO<Scope, never, void> {
-  return IO.acquireRelease(
-    ref.get.flatMap((old) => ref.set(a).as(old)),
-    (a) => ref.set(a),
-  ).asUnit;
+export function locallyScoped<A>(a: A, __tsplusTrace?: string) {
+  return (ref: FiberRef<A>): IO<Scope, never, void> => {
+    return IO.acquireRelease(
+      ref.get.flatMap((old) => ref.set(a).as(old)),
+      (a) => ref.set(a),
+    ).asUnit;
+  };
 }

package/_src/FiberRef/api/locallyScopedWith.ts

@@ -1,10 +1,8 @@
 /**
- * @tsplus fluent fncts.io.FiberRef locallyScopedWith
+ * @tsplus pipeable fncts.io.FiberRef locallyScopedWith
  */
-export function locallyScopedWith<A>(
-  self: FiberRef<A>,
-  f: (a: A) => A,
-  __tsplusTrace?: string,
-): IO<Scope, never, void> {
-  return self.getWith((a) => self.locallyScoped(f(a)));
+export function locallyScopedWith<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (self: FiberRef<A>): IO<Scope, never, void> => {
+    return self.getWith((a) => self.locallyScoped(f(a)));
+  };
 }

package/_src/FiberRef/api.ts

@@ -1,32 +1,37 @@
-import { identity } from "@fncts/base/data/function";
 import { concrete } from "@fncts/io/FiberRef/definition";
 
 /**
- * @tsplus fluent fncts.io.FiberRef modify
+ * @tsplus pipeable fncts.io.FiberRef modify
  */
-export function modify_<A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B> {
-  concrete(self);
-  return IO.withFiberContext((fiber) =>
-    IO(() => {
-      const [result, newValue] = f(fiber.unsafeGetRef(self));
-      fiber.unsafeSetRef(self, newValue);
-      return result;
-    }),
-  );
+export function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+  return (self: FiberRef<A>): UIO<B> => {
+    concrete(self);
+    return IO.withFiberContext((fiber) =>
+      IO(() => {
+        const [result, newValue] = f(fiber.unsafeGetRef(self));
+        fiber.unsafeSetRef(self, newValue);
+        return result;
+      }),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef update
+ * @tsplus pipeable fncts.io.FiberRef update
  */
-export function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<void> {
-  return fiberRef.modify((a) => [undefined, f(a)]);
+export function update<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify((a) => [undefined, f(a)]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef set
+ * @tsplus pipeable fncts.io.FiberRef set
  */
-export function set_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<void> {
-  return fiberRef.modify(() => [undefined, a]);
+export function set<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify(() => [undefined, a]);
+  };
 }
 
 /**
@@ -37,24 +42,30 @@ export function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A> {
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndSet
+ * @tsplus pipeable fncts.io.FiberRef getAndSet
  */
-export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((v) => [v, a]);
+export function getAndSet<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((v) => [v, a]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdate
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdate
  */
-export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((a) => [a, f(a)]);
+export function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((a) => [a, f(a)]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdateJust
  */
-export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
+export function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
+  };
 }
 
 /**
@@ -64,7 +75,7 @@ export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A
  *
  * @tsplus fluent fncts.io.FiberRef locally
  */
-export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
+export function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> =>
     IO.withFiberContext((fiber) =>
       IO.defer(() => {
@@ -87,19 +98,17 @@ export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: str
  *
  * @tsplus fluent fncts.io.FiberRef locallyWith
  */
-export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
+export function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => self.getWith((a) => self.locally(f(a))(use));
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getWith
+ * @tsplus pipeable fncts.io.FiberRef getWith
  */
-export function getWith_<A, R, E, B>(
-  fiberRef: FiberRef<A>,
-  f: (a: A) => IO<R, E, B>,
-  __tsplusTrace?: string,
-): IO<R, E, B> {
-  return IO.withFiberContext((fiber) => f(fiber.unsafeGetRef(fiberRef)));
+export function getWith<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): IO<R, E, B> => {
+    return IO.withFiberContext((fiber) => f(fiber.unsafeGetRef(fiberRef)));
+  };
 }
 
 /**
@@ -150,9 +159,11 @@ export function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patc
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef join
+ * @tsplus pipeable fncts.io.FiberRef join
  */
-export function join<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>, oldValue: Value, newValue: Value): Value {
-  concrete(self);
-  return self._join(oldValue, newValue);
+export function join<Value>(oldValue: Value, newValue: Value) {
+  return <Patch>(self: FiberRef.WithPatch<Value, Patch>): Value => {
+    concrete(self);
+    return self._join(oldValue, newValue);
+  };
 }

package/_src/FiberRef.ts

@@ -4,7 +4,6 @@ export * from "./FiberRef/constructors.js";
 export * from "./FiberRef/definition.js";
 export * from "./FiberRef/unsafe.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: ./FiberRef/api/*.ts }
 export * from "./FiberRef/api/locallyScoped.js";
 export * from "./FiberRef/api/locallyScopedWith.js";

package/_src/FiberRefs/api.ts

@@ -15,17 +15,19 @@ export function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [F
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus pipeable fncts.io.FiberRefs forkAs
  */
-export function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs {
-  const childFiberRefLocals = self.fiberRefLocals.mapWithIndex((fiberRef, stack) => {
-    const oldValue = stack.head[1];
-    const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
-    if (oldValue === newValue) {
-      return stack;
-    } else {
-      return Cons([childId, newValue], stack);
-    }
-  });
-  return FiberRefs(childFiberRefLocals);
+export function forkAs(childId: FiberId.Runtime) {
+  return (self: FiberRefs): FiberRefs => {
+    const childFiberRefLocals = self.fiberRefLocals.mapWithIndex((fiberRef, stack) => {
+      const oldValue = stack.head[1];
+      const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
+      if (oldValue === newValue) {
+        return stack;
+      } else {
+        return Cons([childId, newValue], stack);
+      }
+    });
+    return FiberRefs(childFiberRefLocals);
+  };
 }

package/_src/FiberRefs/join.ts

@@ -1,53 +1,44 @@
 /**
- * @tsplus fluent fncts.io.FiberRefs join
+ * @tsplus pipeable fncts.io.FiberRefs join
  */
-export function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs): FiberRefs {
-  const parentFiberRefs = self.fiberRefLocals;
-  const childFiberRefs  = that.fiberRefLocals;
-
-  const fiberRefLocals = childFiberRefs.foldLeftWithIndex(parentFiberRefs, (ref, parentFiberRefs, childStack) => {
-    const childValue = childStack.head[1];
-
-    if (childStack.head[0] == fiberId) {
-      return parentFiberRefs;
-    }
-
-    return parentFiberRefs.get(ref).match(
-      () => {
-        if (Equatable.strictEquals(childValue, ref.initial)) return parentFiberRefs;
-        return parentFiberRefs.set(ref, Cons([fiberId, childValue] as const));
-      },
-      (parentStack) => {
-        const [ancestor, wasModified] = findAncestor(ref, parentStack, childStack);
-
-        if (!wasModified) return parentFiberRefs;
-
-        const patch = ref.diff(ancestor, childValue);
-
-        const oldValue = parentStack.head[1];
-        const newValue = ref.join(oldValue, ref.patch(patch)(oldValue));
-
-        if (oldValue === newValue) return parentFiberRefs;
-
-        let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
-
-        if (parentStack.isEmpty()) {
-          newStack = Cons([fiberId, newValue] as const);
-        } else {
-          const [parentFiberId] = parentStack.head;
-          if (parentFiberId == fiberId) {
-            newStack = Cons([parentFiberId, newValue], parentStack.tail);
+export function join(fiberId: FiberId.Runtime, that: FiberRefs) {
+  return (self: FiberRefs): FiberRefs => {
+    const parentFiberRefs = self.fiberRefLocals;
+    const childFiberRefs  = that.fiberRefLocals;
+    const fiberRefLocals  = childFiberRefs.foldLeftWithIndex(parentFiberRefs, (ref, parentFiberRefs, childStack) => {
+      const childValue = childStack.head[1];
+      if (childStack.head[0] == fiberId) {
+        return parentFiberRefs;
+      }
+      return parentFiberRefs.get(ref).match(
+        () => {
+          if (Equatable.strictEquals(childValue, ref.initial)) return parentFiberRefs;
+          return parentFiberRefs.set(ref, Cons([fiberId, childValue] as const));
+        },
+        (parentStack) => {
+          const [ancestor, wasModified] = findAncestor(ref, parentStack, childStack);
+          if (!wasModified) return parentFiberRefs;
+          const patch    = ref.diff(ancestor, childValue);
+          const oldValue = parentStack.head[1];
+          const newValue = ref.join(oldValue, ref.patch(patch)(oldValue));
+          if (oldValue === newValue) return parentFiberRefs;
+          let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
+          if (parentStack.isEmpty()) {
+            newStack = Cons([fiberId, newValue] as const);
           } else {
-            newStack = Cons([fiberId, newValue], parentStack);
+            const [parentFiberId] = parentStack.head;
+            if (parentFiberId == fiberId) {
+              newStack = Cons([parentFiberId, newValue], parentStack.tail);
+            } else {
+              newStack = Cons([fiberId, newValue], parentStack);
+            }
           }
-        }
-
-        return parentFiberRefs.set(ref, newStack);
-      },
-    );
-  });
-
-  return FiberRefs(fiberRefLocals);
+          return parentFiberRefs.set(ref, newStack);
+        },
+      );
+    });
+    return FiberRefs(fiberRefLocals);
+  };
 }
 
 function compareFiberId(left: FiberId.Runtime, right: FiberId.Runtime): number {

package/_src/FiberState/definition.ts

@@ -34,8 +34,7 @@ export class Executing<E, A> {
 }
 
 export class Done<E, A> {
-  readonly _tag = "Done";
-
+  readonly _tag                       = "Done";
   readonly interrupted                = Cause.empty<never>();
   readonly status: FiberStatus        = FiberStatus.done;
   readonly interruptors: Set<FiberId> = new Set();