@fncts/io 0.0.34 → 0.0.35

package/_src/IO/api.ts

@@ -6,17 +6,8 @@ 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,
-  GenerateStackTrace,
-  OnSuccess,
-  OnSuccessAndFailure,
-  Sync,
-  UpdateRuntimeFlags,
-  YieldNow,
-} from "@fncts/io/IO/definition";
-import { Stateful } from "@fncts/io/IO/definition";
-import { Fail, IO, SucceedNow } from "@fncts/io/IO/definition";
+import { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
+import { IO } from "@fncts/io/IO/definition";
 
 /**
  * Imports an asynchronous side-effect into a `IO`
@@ -28,7 +19,11 @@ export function async<R, E, A>(
   blockingOn: FiberId = FiberId.none,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new Async(register, () => blockingOn, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Async) as any;
+  io.i0    = register;
+  io.i1    = () => blockingOn;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -318,7 +313,11 @@ export function checkInterruptible<R, E, A>(
  */
 export function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string) {
   return <R, E>(ma: IO<R, E, A>): IO<R | R1, E | E1, B> => {
-    return new OnSuccess(ma, f, __tsplusTrace);
+    const io = new IOPrimitive(IOTag.OnSuccess) as any;
+    io.i0    = ma;
+    io.i1    = f;
+    io.trace = __tsplusTrace;
+    return io;
   };
 }
 
@@ -369,7 +368,7 @@ export function condIO<R, R1, E, A>(
  *
  * @tsplus static fncts.io.IOOps defer
  */
-export function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
+export function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
   return IO.succeed(io).flatMap(identity);
 }
 
@@ -379,7 +378,10 @@ export function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): I
  *
  * @tsplus static fncts.io.IOOps deferTry
  */
-export function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A> {
+export function deferTry<R = never, E = never, A = never>(
+  io: () => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, unknown, A> {
   return IO.defer(() => {
     try {
       return io();
@@ -463,7 +465,10 @@ export function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never> {
  * @tsplus static fncts.io.IOOps refailCause
  */
 export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => cause, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = () => cause;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -472,7 +477,10 @@ export function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E,
  * @tsplus static fncts.io.IOOps failCauseNow
  */
 export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never> {
-  return new Fail(() => cause, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Fail) as any;
+  io.i0    = () => cause;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1223,7 +1231,12 @@ export function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(
   __tsplusTrace?: string,
 ) {
   return <R>(self: IO<R, E, A>): IO<R | R1 | R2, E1 | E2, A1 | A2> => {
-    return new OnSuccessAndFailure(self, onFailure, onSuccess, __tsplusTrace);
+    const io = new IOPrimitive(IOTag.OnSuccessAndFailure) as any;
+    io.i0    = self;
+    io.i1    = onFailure;
+    io.i2    = onSuccess;
+    io.trace = __tsplusTrace;
+    return io;
   };
 }
 
@@ -1664,7 +1677,10 @@ export function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A>>, __ts
  * @tsplus static fncts.io.IOOps succeedNow
  */
 export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A> {
-  return new SucceedNow(value, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.SucceedNow) as any;
+  io.i0    = value;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1676,7 +1692,10 @@ export function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never
  * @tsplus static fncts.io.IOOps __call
  */
 export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
-  return new Sync(effect, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Sync) as any;
+  io.i0    = effect;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1721,17 +1740,42 @@ export function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: st
     ma.summarized(msTime, (start, end) => end - start);
 }
 
+/**
+ * @tsplus static fncts.io.IOOps attempt
+ */
+export function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A> {
+  return IO.defer(() => {
+    try {
+      return Exit.succeed(effect());
+    } catch (u) {
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(u));
+        } else {
+          throw u;
+        }
+      });
+    }
+  });
+}
+
 /**
  * Creates a `IO` that has succeeded with a pure value
  *
  * @tsplus static fncts.io.IOOps tryCatch
  */
 export function tryCatch<E, A>(effect: Lazy<A>, onThrow: (error: unknown) => E, __tsplusTrace?: string): FIO<E, A> {
-  return IO.succeed(() => {
+  return IO.defer(() => {
     try {
-      return effect();
+      return Exit.succeed(effect());
     } catch (u) {
-      throw new IOError(Cause.fail(onThrow(u)));
+      return IO.withFiberRuntime((fiberState) => {
+        if (!fiberState.isFatal(u)) {
+          throw new IOError(Cause.fail(u));
+        } else {
+          throw u;
+        }
+      });
     }
   });
 }
@@ -1902,21 +1946,29 @@ export function withFiberRuntime<R, E, A>(
   onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new Stateful(onState, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.Stateful) as any;
+  io.i0    = onState;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
  * @tsplus static fncts.io.IOOps updateRuntimeFlags
  */
 export function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void> {
-  return new UpdateRuntimeFlags(patch, __tsplusTrace);
+  const io = new IOPrimitive(IOTag.UpdateRuntimeFlags) as any;
+  io.i0    = patch;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
  * @tsplus static fncts.io.IOOps stackTrace
  */
 export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
-  return new GenerateStackTrace(__tsplusTrace);
+  const io = new IOPrimitive(IOTag.GenerateStackTrace) as any;
+  io.trace = __tsplusTrace;
+  return io;
 }
 
 /**
@@ -1926,7 +1978,7 @@ export function stackTrace(__tsplusTrace?: string): UIO<Trace> {
  *
  * @tsplus static fncts.io.IOOps yieldNow
  */
-export const yieldNow: UIO<void> = new YieldNow();
+export const yieldNow: UIO<void> = new IOPrimitive(IOTag.YieldNow) as any;
 
 /**
  * @tsplus pipeable fncts.io.IO zip

package/_src/IO/definition.ts

@@ -1,13 +1,11 @@
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
+import type { RuntimeFlags } 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";
-import { RuntimeFlags } from "../RuntimeFlags.js";
-
 export const IOVariance = Symbol.for("fncts.io.IO.Variance");
 export type IOVariance = typeof IOVariance;
 
@@ -36,6 +34,10 @@ export abstract class IO<R, E, A> {
   };
 }
 
+export type EnvironmentOf<T> = [T] extends [{ [IOVariance]: { _R: () => infer R } }] ? R : never;
+export type ErrorOf<T> = [T] extends [{ [IOVariance]: { _E: () => infer E } }] ? E : never;
+export type ValueOf<T> = [T] extends [{ [IOVariance]: { _A: () => infer A } }] ? A : never;
+
 declare module "@fncts/base/data/Either/definition" {
   interface Either<E, A> extends IO<never, E, A> {}
 }
@@ -76,7 +78,7 @@ export type URIO<R, A> = IO<R, never, A>;
 
 export type FIO<E, A> = IO<never, E, A>;
 
-export const enum IOOpCode {
+export const enum IOTag {
   SucceedNow,
   Fail,
   Sync,
@@ -95,199 +97,161 @@ export const enum IOOpCode {
   UpdateTrace,
 }
 
-export function isIO(u: unknown): u is IO<any, any, any> {
-  return isObject(u) && IOTypeId in u;
-}
-
-export class Sync<A> extends IO<never, never, A> {
-  readonly _tag = IOOpCode.Sync;
-  constructor(readonly evaluate: () => A, readonly trace?: string) {
-    super();
-  }
-}
-
-export class Async<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOOpCode.Async;
-  constructor(
-    readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any,
-    readonly blockingOn: () => FiberId,
-    readonly trace?: string,
-  ) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-  readonly _tag = IOOpCode.OnSuccessAndFailure;
-
-  constructor(
-    readonly first: IO<R, E, A>,
-    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
-    readonly successK: (a: A) => IO<R2, E2, C>,
-    readonly trace?: string,
-  ) {
-    super();
-  }
-
-  onFailure(c: Cause<E>): IO<R | R1 | R2, E1 | E2, B | C> {
-    return this.failureK(c);
-  }
-  onSuccess(a: A): IO<R | R1 | R2, E1 | E2, B | C> {
-    return this.successK(a);
-  }
-}
-
-export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
-  readonly _tag = IOOpCode.OnFailure;
-  constructor(
-    readonly first: IO<R, E, A>,
-    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
-    readonly trace?: string,
-  ) {
-    super();
-  }
-
-  onFailure(c: Cause<E>): IO<R | R1, E1, A | B> {
-    return this.failureK(c);
-  }
-  onSuccess(a: A): IO<R | R1, E1, A | B> {
-    return new SucceedNow(a);
-  }
-}
-
-/**
- * @internal
- */
-export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-  readonly _tag = IOOpCode.OnSuccess;
-  constructor(readonly first: IO<R, E, A>, readonly successK: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
-    super();
-  }
-  onFailure(c: Cause<E>): IO<R | R1, E | E1, A1> {
-    return new Fail(c);
-  }
-  onSuccess(a: A): IO<R | R1, E | E1, A1> {
-    return this.successK(a);
-  }
-}
-
-/**
- * @internal
- */
-export class SucceedNow<A> extends IO<never, never, A> {
-  readonly _tag = IOOpCode.SucceedNow;
-  constructor(readonly value: A, readonly trace?: string) {
-    super();
-  }
-}
-
-export class UpdateRuntimeFlags extends IO<never, never, void> {
-  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 _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-  constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-
-  readonly update: RuntimeFlags.Patch = RuntimeFlags.enable(RuntimeFlag.Interruption);
-  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
-    return this.effect;
-  }
-}
-
-export class Uninterruptible<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-  constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-
-  readonly update: RuntimeFlags.Patch = RuntimeFlags.disable(RuntimeFlag.Interruption);
-  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
-    return this.effect;
-  }
-}
-
-export class Dynamic<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-  constructor(
-    readonly update: RuntimeFlagsPatch,
-    readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>,
-    readonly trace?: string,
-  ) {
-    super();
-  }
-
-  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
-    return this.f(oldRuntimeFlags);
-  }
-}
-
-export class GenerateStackTrace extends IO<never, never, Trace> {
-  readonly _tag = IOOpCode.GenerateStackTrace;
-  constructor(readonly trace?: string) {
-    super();
-  }
-}
-
-export class Stateful<R, E, A> extends IO<R, E, A> {
-  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 _tag = IOOpCode.WhileLoop;
-  constructor(
-    readonly check: () => boolean,
-    readonly body: () => IO<R, E, A>,
-    readonly process: (a: A) => any,
-    readonly trace?: string,
-  ) {
-    super();
-  }
-}
+export type IOOp<Tag extends string | number, Body = {}> = IO<never, never, never> &
+  Body & {
+    readonly _tag: Tag;
+  };
 
-export class YieldNow extends IO<never, never, void> {
-  readonly _tag = IOOpCode.YieldNow;
-  constructor(readonly trace?: string) {
-    super();
-  }
+export class IOPrimitive {
+  public i0: any                   = undefined;
+  public i1: any                   = undefined;
+  public i2: any                   = undefined;
+  public trace: string | undefined = undefined;
+  [IOTypeId] = IOTypeId;
+  constructor(readonly _tag: Primitive["_tag"]) {}
 }
 
-/**
- * @internal
- */
-export class Fail<E> extends IO<never, E, never> {
-  readonly _tag = IOOpCode.Fail;
-
-  constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
-    super();
-  }
+export function isIO(u: unknown): u is IO<any, any, any> {
+  return isObject(u) && IOTypeId in u;
 }
 
-export type Concrete =
-  | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any>
-  | OnFailure<any, any, any, any, any, any>
-  | OnSuccess<any, any, any, any, any, any>
+export interface Sync<A = any>
+  extends IOOp<
+    IOTag.Sync,
+    {
+      readonly i0: () => A;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface Async<R = any, E = any, A = any>
+  extends IOOp<
+    IOTag.Async,
+    {
+      readonly i0: (resume: (io: Primitive) => void) => void;
+      readonly i1: () => FiberId;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface OnSuccessAndFailure
+  extends IOOp<
+    IOTag.OnSuccessAndFailure,
+    {
+      readonly i0: Primitive;
+      readonly i1: (cause: Cause<unknown>) => Primitive;
+      readonly i2: (a: unknown) => Primitive;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface OnFailure
+  extends IOOp<
+    IOTag.OnFailure,
+    {
+      readonly i0: Primitive;
+      readonly i1: (cause: Cause<unknown>) => Primitive;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface OnSuccess
+  extends IOOp<
+    IOTag.OnSuccess,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: unknown) => Primitive;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface SucceedNow
+  extends IOOp<
+    IOTag.SucceedNow,
+    {
+      readonly i0: any;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface UpdateRuntimeFlags
+  extends IOOp<
+    IOTag.UpdateRuntimeFlags,
+    {
+      readonly i0: RuntimeFlags.Patch;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface UpdateRuntimeFlagsWithin
+  extends IOOp<
+    IOTag.UpdateRuntimeFlagsWithin,
+    {
+      readonly i0: RuntimeFlagsPatch;
+      readonly i1: (oldRuntimeFlags: RuntimeFlags) => Primitive;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface GenerateStackTrace
+  extends IOOp<
+    IOTag.GenerateStackTrace,
+    {
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface Stateful
+  extends IOOp<
+    IOTag.Stateful,
+    {
+      readonly i0: (fiber: FiberRuntime<any, any>, status: Running) => Primitive;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface WhileLoop
+  extends IOOp<
+    IOTag.WhileLoop,
+    {
+      readonly i0: () => boolean;
+      readonly i1: () => Primitive;
+      readonly i2: (a: any) => any;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface YieldNow
+  extends IOOp<
+    IOTag.YieldNow,
+    {
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export interface Fail
+  extends IOOp<
+    IOTag.Fail,
+    {
+      readonly i0: () => Cause<unknown>;
+      readonly trace: string | undefined;
+    }
+  > {}
+
+export type Primitive =
+  | OnSuccessAndFailure
+  | OnFailure
+  | OnSuccess
   | UpdateRuntimeFlagsWithin
-  | Sync<any>
-  | Async<any, any, any>
-  | SucceedNow<any>
+  | Sync
+  | Async
+  | SucceedNow
   | UpdateRuntimeFlags
   | GenerateStackTrace
-  | Stateful<any, any, any>
-  | WhileLoop<any, any, any>
+  | Stateful
+  | WhileLoop
   | YieldNow
-  | Fail<any>
+  | Fail
   | STM<any, any, any>
   | Left<any>
   | Right<any>
@@ -300,18 +264,10 @@ export type Concrete =
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
  */
-export function concrete(io: IO<any, any, any>): Concrete {
-  return io as Concrete;
+export function concrete(io: IO<any, any, any>): Primitive {
+  return io as Primitive;
 }
 
-export type EvaluationStep =
-  | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any>
-  | OnFailure<any, any, any, any, any, any>
-  | OnSuccess<any, any, any, any, any, any>;
-
-export type UpdateRuntimeFlagsWithin =
-  | Interruptible<any, any, any>
-  | Uninterruptible<any, any, any>
-  | Dynamic<any, any, any>;
+export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
 
 export type Canceler<R> = URIO<R, void>;

package/_src/IO.ts

@@ -11,6 +11,7 @@ export * from "./IO/api/acquireReleaseInterruptible.js";
 export * from "./IO/api/acquireReleaseInterruptibleExit.js";
 export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/all.js";
 export * from "./IO/api/asyncInterrupt.js";
 export * from "./IO/api/asyncIO.js";
 export * from "./IO/api/blocking.js";