@fncts/io 0.0.31 → 0.0.33

package/_src/IO/api/zipConcurrent.ts

@@ -1,16 +1,14 @@
 import type { InterruptibilityRestorer } from "./interrupt.js";
 import type { Grafter } from "./transplant.js";
 
-import { tuple } from "@fncts/base/data/function";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 
 /**
  * @tsplus pipeable fncts.io.IO zipConcurrent
  */
 export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, readonly [A, B]> => {
-    return self.zipWithConcurrent(that, tuple);
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, Zipped.Make<A, B>> => {
+    return self.zipWithConcurrent(that, (a, b) => Zipped(a, b));
   };
 }
 
@@ -19,32 +17,30 @@ export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: st
  */
 export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, C> => {
-    return IO.fiberId.flatMap((fiberId) =>
-      IO.uninterruptibleMask((restore) => {
-        return IO.transplant((graft) => {
-          const future = Future.unsafeMake<void, void>(FiberId.none);
-          const ref    = new AtomicBoolean(false);
-          return fork(self, restore, graft, future, ref)
-            .zip(fork(that, restore, graft, future, ref))
-            .flatMap(([left, right]) =>
-              restore(future.await).matchCauseIO(
-                (cause) =>
-                  left.interruptFork >
-                  right.interruptFork >
-                  left.await.zip(right.await).flatMap(([left, right]) =>
-                    left
-                      .zipWithCause(right, f, (a, b) => Cause.both(a, b))
-                      .match(
-                        (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
-                        () => IO.refailCause(cause.stripFailures),
-                      ),
-                  ),
-                () => left.join.zipWith(right.join, f),
-              ),
-            );
-        });
-      }),
-    );
+    return IO.uninterruptibleMask((restore) => {
+      return IO.transplant((graft) => {
+        const future = Future.unsafeMake<void, void>(FiberId.none);
+        const ref    = new AtomicBoolean(false);
+        return fork(self, restore, graft, future, ref)
+          .zip(fork(that, restore, graft, future, ref))
+          .flatMap(([left, right]) =>
+            restore(future.await).matchCauseIO(
+              (cause) =>
+                left.interruptFork >
+                right.interruptFork >
+                left.await.zip(right.await).flatMap(([left, right]) =>
+                  left
+                    .zipWithCause(right, f, (a, b) => Cause.both(a, b))
+                    .match(
+                      (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
+                      () => IO.refailCause(cause.stripFailures),
+                    ),
+                ),
+              () => left.join.zipWith(right.join, f),
+            ),
+          );
+      });
+    });
   };
 }
 

package/_src/IO/api.ts

@@ -4,6 +4,7 @@ import type { _E, _R } from "@fncts/base/types";
 import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
+import { IOError } from "@fncts/base/data/exceptions";
 import { identity, pipe, tuple } from "@fncts/base/data/function";
 import {
   Async,
@@ -15,7 +16,7 @@ import {
   YieldNow,
 } from "@fncts/io/IO/definition";
 import { Stateful } from "@fncts/io/IO/definition";
-import { Fail, IO, IOError, SucceedNow } from "@fncts/io/IO/definition";
+import { Fail, IO, SucceedNow } from "@fncts/io/IO/definition";
 
 /**
  * Imports an asynchronous side-effect into a `IO`
@@ -851,8 +852,8 @@ export function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: string): FIO
  * @tsplus static fncts.io.IOOps fromMaybeNow
  * @tsplus getter fncts.Maybe toIO
  */
-export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<unknown, Maybe<never>, A> {
-  return maybe.match(() => IO.failNow(Nothing()), IO.succeedNow);
+export function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<never, NoSuchElementError, A> {
+  return maybe.match(() => IO.failNow(new NoSuchElementError("IO.fromMaybeNow")), IO.succeedNow);
 }
 
 /**

package/_src/IO/definition.ts

@@ -1,6 +1,8 @@
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
+import type { Left, Right } from "@fncts/base/data/Either";
+import type { Failure, Success } from "@fncts/base/data/Exit";
 import type { Trace } from "@fncts/base/data/Trace";
 
 import { RuntimeFlag } from "../RuntimeFlag.js";
@@ -34,6 +36,17 @@ export abstract class IO<R, E, A> {
   };
 }
 
+declare module "@fncts/base/data/Either/definition" {
+  interface Either<E, A> extends IO<never, E, A> {}
+}
+declare module "@fncts/base/data/Maybe/definition" {
+  interface Maybe<A> extends IO<never, NoSuchElementError, A> {}
+}
+declare module "@fncts/base/data/Exit/definition" {
+  interface Success<A> extends IO<never, never, A> {}
+  interface Failure<E> extends IO<never, E, never> {}
+}
+
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -87,14 +100,14 @@ export function isIO(u: unknown): u is IO<any, any, any> {
 }
 
 export class Sync<A> extends IO<never, never, A> {
-  readonly ioOpCode = IOOpCode.Sync;
+  readonly _tag = IOOpCode.Sync;
   constructor(readonly evaluate: () => A, readonly trace?: string) {
     super();
   }
 }
 
 export class Async<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.Async;
+  readonly _tag = IOOpCode.Async;
   constructor(
     readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any,
     readonly blockingOn: () => FiberId,
@@ -108,7 +121,7 @@ export class Async<R, E, A> extends IO<R, E, A> {
  * @internal
  */
 export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-  readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
+  readonly _tag = IOOpCode.OnSuccessAndFailure;
 
   constructor(
     readonly first: IO<R, E, A>,
@@ -128,7 +141,7 @@ export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R
 }
 
 export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
-  readonly ioOpCode = IOOpCode.OnFailure;
+  readonly _tag = IOOpCode.OnFailure;
   constructor(
     readonly first: IO<R, E, A>,
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
@@ -149,7 +162,7 @@ export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
  * @internal
  */
 export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-  readonly ioOpCode = IOOpCode.OnSuccess;
+  readonly _tag = IOOpCode.OnSuccess;
   constructor(readonly first: IO<R, E, A>, readonly successK: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
     super();
   }
@@ -165,21 +178,21 @@ export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
  * @internal
  */
 export class SucceedNow<A> extends IO<never, never, A> {
-  readonly ioOpCode = IOOpCode.SucceedNow;
+  readonly _tag = IOOpCode.SucceedNow;
   constructor(readonly value: A, readonly trace?: string) {
     super();
   }
 }
 
 export class UpdateRuntimeFlags extends IO<never, never, void> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlags;
+  readonly _tag = IOOpCode.UpdateRuntimeFlags;
   constructor(readonly update: RuntimeFlags.Patch, readonly trace?: string) {
     super();
   }
 }
 
 export class Interruptible<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -191,7 +204,7 @@ export class Interruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Uninterruptible<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -203,7 +216,7 @@ export class Uninterruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Dynamic<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(
     readonly update: RuntimeFlagsPatch,
     readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>,
@@ -218,21 +231,21 @@ export class Dynamic<R, E, A> extends IO<R, E, A> {
 }
 
 export class GenerateStackTrace extends IO<never, never, Trace> {
-  readonly ioOpCode = IOOpCode.GenerateStackTrace;
+  readonly _tag = IOOpCode.GenerateStackTrace;
   constructor(readonly trace?: string) {
     super();
   }
 }
 
 export class Stateful<R, E, A> extends IO<R, E, A> {
-  readonly ioOpCode = IOOpCode.Stateful;
+  readonly _tag = IOOpCode.Stateful;
   constructor(readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, readonly trace?: string) {
     super();
   }
 }
 
 export class WhileLoop<R, E, A> extends IO<R, E, void> {
-  readonly ioOpCode = IOOpCode.WhileLoop;
+  readonly _tag = IOOpCode.WhileLoop;
   constructor(
     readonly check: () => boolean,
     readonly body: () => IO<R, E, A>,
@@ -244,7 +257,7 @@ export class WhileLoop<R, E, A> extends IO<R, E, void> {
 }
 
 export class YieldNow extends IO<never, never, void> {
-  readonly ioOpCode = IOOpCode.YieldNow;
+  readonly _tag = IOOpCode.YieldNow;
   constructor(readonly trace?: string) {
     super();
   }
@@ -254,7 +267,7 @@ export class YieldNow extends IO<never, never, void> {
  * @internal
  */
 export class Fail<E> extends IO<never, E, never> {
-  readonly ioOpCode = IOOpCode.Fail;
+  readonly _tag = IOOpCode.Fail;
 
   constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
     super();
@@ -275,7 +288,13 @@ export type Concrete =
   | WhileLoop<any, any, any>
   | YieldNow
   | Fail<any>
-  | STM<any, any, any>;
+  | STM<any, any, any>
+  | Left<any>
+  | Right<any>
+  | Nothing
+  | Just<any>
+  | Failure<any>
+  | Success<any>;
 
 /**
  * @tsplus static fncts.io.IOOps concrete
@@ -296,15 +315,3 @@ export type UpdateRuntimeFlagsWithin =
   | Dynamic<any, any, any>;
 
 export type Canceler<R> = URIO<R, void>;
-
-export const IOErrorTypeId = Symbol.for("fncts.io.IO.IOError");
-export type IOErrorTypeId = typeof IOErrorTypeId;
-
-export class IOError<E> {
-  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
-  constructor(readonly cause: Cause<E>) {}
-}
-
-export function isIOError(u: unknown): u is IOError<unknown> {
-  return isObject(u) && IOErrorTypeId in u;
-}

package/_src/IO/runtime.ts

@@ -1,4 +1,5 @@
-import { FiberMessage, FiberRuntime } from "@fncts/io/Fiber";
+import { IOError } from "@fncts/base/data/exceptions";
+import { FiberRuntime } from "@fncts/io/Fiber";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
@@ -12,7 +13,7 @@ export class Runtime<R> {
     readonly fiberRefs: FiberRefs,
   ) {}
 
-  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
+  makeFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
     const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
 
@@ -31,35 +32,39 @@ export class Runtime<R> {
 
     FiberScope.global.unsafeAdd(null!, fiber.runtimeFlags0, fiber);
 
-    fiber.start(io);
-
     return fiber;
   };
 
-  unsafeRunWith = <E, A>(
-    io: IO<R, E, A>,
-    k: (exit: Exit<E, A>) => any,
-    __tsplusTrace?: string,
-  ): ((fiberId: FiberId) => (f: (exit: Exit<E, A>) => any) => void) => {
-    const fiber = this.unsafeRunFiber(io);
-    fiber.tell(FiberMessage.Stateful((fiber) => fiber.addObserver(k)));
-    return (fiberId) => (k) => this.unsafeRunAsyncWith(fiber.interruptAs(fiberId), (exit) => k(exit.flatten));
-  };
-
-  unsafeRunAsync = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => {
-    this.unsafeRunAsyncWith(io, () => void 0);
+  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
+    const fiber = this.makeFiber(io);
+    fiber.start(io);
+    return fiber;
   };
 
-  unsafeRunAsyncWith = <E, A>(io: IO<R, E, A>, k: (exit: Exit<E, A>) => any, __tsplusTrace?: string) => {
-    this.unsafeRunWith(io, k);
+  unsafeRunPromiseExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<Exit<E, A>> => {
+    return new Promise((resolve) => {
+      const fiber = this.makeFiber(io);
+      fiber.addObserver((exit) => {
+        resolve(exit);
+      });
+      fiber.start(io);
+    });
   };
 
-  unsafeRunPromiseExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<Exit<E, A>> =>
-    new Promise((resolve) => {
-      this.unsafeRunAsyncWith(io, resolve);
+  unsafeRunPromise = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Promise<A> => {
+    return new Promise((resolve, reject) => {
+      const fiber = this.makeFiber(io);
+      fiber.addObserver((exit) => {
+        if (exit.isFailure()) {
+          reject(new IOError(exit.cause));
+        } else {
+          resolve(exit.value);
+        }
+      });
     });
+  };
 
-  unsafeRunSyncExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+  unsafeRunOrFork = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Either<Fiber.Runtime<E, A>, Exit<E, A>> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
     const scheduler = new StagedScheduler();
     const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
@@ -83,10 +88,16 @@ export class Runtime<R> {
 
     const result = fiber.exitValue();
     if (result !== null) {
-      return result;
+      return Either.right(result);
     }
 
-    return Exit.halt(fiber);
+    return Either.left(fiber);
+  };
+
+  unsafeRun = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+    return this.unsafeRunOrFork(io).match(() => {
+      throw new Error("Encountered async boundary");
+    }, Function.identity);
   };
 }
 
@@ -112,27 +123,17 @@ export const defaultRuntime = new Runtime(Environment.empty, RuntimeFlags.defaul
  */
 export const unsafeRunFiber = defaultRuntime.unsafeRunFiber;
 
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsync
- */
-export const unsafeRunAsync = defaultRuntime.unsafeRunAsync;
-
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsyncWith
- */
-export const unsafeRunAsyncWith = defaultRuntime.unsafeRunAsyncWith;
-
 /**
  * @tsplus fluent fncts.io.IO unsafeRunPromiseExit
  */
 export const unsafeRunPromiseExit = defaultRuntime.unsafeRunPromiseExit;
 
 /**
- * @tsplus fluent fncts.io.IO unsafeRunWith
+ * @tsplus getter fncts.io.IO unsafeRunOrFork
  */
-export const unsafeRunWith = defaultRuntime.unsafeRunWith;
+export const unsafeRunOrFork = defaultRuntime.unsafeRunOrFork;
 
 /**
- * @tsplus getter fncts.io.IO unsafeRunSyncExit
+ * @tsplus getter fncts.io.IO unsafeRun
  */
-export const unsafeRunSyncExit = defaultRuntime.unsafeRunSyncExit;
+export const unsafeRun = defaultRuntime.unsafeRun;

package/_src/Queue/api/filterInputIO.ts

@@ -1,6 +1,6 @@
 import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
+import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,6 @@
 import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, DequeueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
+import { concrete, DequeueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {

package/_src/RefSubject/Atomic.ts

@@ -53,15 +53,15 @@ export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
   end: IO<never, never, void> = this.stream.end;
 
   unsafeEmit(value: A): void {
-    return this.stream.emit(value).unsafeRunAsync();
+    this.stream.emit(value).unsafeRunFiber();
   }
 
   unsafeFailCause(cause: Cause<E>): void {
-    return this.stream.failCause(cause).unsafeRunAsync();
+    this.stream.failCause(cause).unsafeRunFiber();
   }
 
   unsafeEnd(): void {
-    return this.stream.end.unsafeRunAsync();
+    this.stream.end.unsafeRunFiber();
   }
 
   get unsafeGet(): A {
@@ -111,7 +111,7 @@ class AtomicEmitRef<E, A> extends Atomic<A> {
 
   unsafeSet(value: A) {
     this.ref.unsafeSet(value);
-    this.emitter.emit(value).unsafeRunAsync();
+    this.emitter.emit(value).unsafeRunFiber();
   }
 
   set(value: A, __tsplusTrace?: string) {

package/_src/STM/definition.ts

@@ -25,7 +25,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export abstract class STM<R, E, A> {
   readonly [IOTypeId]: IOTypeId = IOTypeId;
-  readonly ioOpCode             = IOOpCode.Commit;
+  readonly _tag                 = IOOpCode.Commit;
   readonly trace?: string;
   readonly [STMTypeId]: STMTypeId = STMTypeId;
   declare [IOVariance]: {

package/_src/State/definition.ts

@@ -1,4 +1,4 @@
-import type { StateInternal} from "./internal.js";
+import type { StateInternal } from "./internal.js";
 
 import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";