@fncts/io 0.0.15 → 0.0.18

package/_src/IO/api/core-scope.ts

@@ -1,13 +1,13 @@
 import { ExitTag } from "@fncts/base/data/Exit";
 
 import { FiberScope } from "../../FiberScope.js";
-import { Fork, GetForkScope, IO, OverrideForkScope, Race } from "../definition.js";
+import { Fork, IO, Race } from "../definition.js";
 
 /**
  * @tsplus getter fncts.io.IO daemonChildren
  */
 export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.defer(new OverrideForkScope(self, Just(FiberScope.global), __tsplusTrace));
+  return IO.defer(FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self));
 }
 
 /**
@@ -15,7 +15,9 @@ export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: strin
  *
  * @tsplus static fncts.io.IOOps forkScope
  */
-export const forkScope: UIO<FiberScope> = new GetForkScope(IO.succeedNow);
+export const forkScope: UIO<FiberScope> = IO.withFiberContext((fiber) =>
+  IO(fiber.unsafeGetRef(FiberRef.forkScopeOverride).getOrElse(fiber.scope)),
+);
 
 /**
  * Retrieves the scope that will be used to supervise forked effects.
@@ -23,14 +25,14 @@ export const forkScope: UIO<FiberScope> = new GetForkScope(IO.succeedNow);
  * @tsplus static fncts.io.IOOps forkScopeWith
  */
 export function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string) {
-  return new GetForkScope(f, __tsplusTrace);
+  return forkScope.flatMap(f);
 }
 
 export class ForkScopeRestore {
   constructor(private scope: FiberScope) {}
 
   readonly restore = <R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
-    new OverrideForkScope(ma, Just(this.scope), __tsplusTrace);
+    FiberRef.forkScopeOverride.locally(Just(this.scope))(ma);
 }
 
 /**
@@ -45,8 +47,8 @@ export function forkScopeMask_<R, E, A>(
   f: (restore: ForkScopeRestore) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.forkScopeWith(
-    (scope) => new OverrideForkScope(f(new ForkScopeRestore(scope)), Just(newScope), __tsplusTrace),
+  return IO.forkScopeWith((scope) =>
+    FiberRef.forkScopeOverride.locally(Just(newScope))(f(new ForkScopeRestore(scope))),
   );
 }
 
@@ -103,7 +105,7 @@ export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
  * @tsplus static fncts.io.IOOps transplant
  */
 export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return forkScopeWith((scope) => f((e) => new OverrideForkScope(e, Just(scope))));
+  return forkScopeWith((scope) => f((e) => FiberRef.forkScopeOverride.locally(Just(scope))(e)));
 }
 
 /**
@@ -124,7 +126,7 @@ export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): UR
  * @tsplus fluent fncts.io.IO overrideForkScope
  */
 export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): IO<R, E, A> {
-  return new OverrideForkScope(ma, Just(scope), __tsplusTrace);
+  return FiberRef.forkScopeOverride.locally(Just(scope))(ma);
 }
 
 /**
@@ -134,5 +136,5 @@ export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope,
  * @tsplus getter fncts.io.IO defaultForkScope
  */
 export function defaultForkScope<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new OverrideForkScope(ma, Nothing(), __tsplusTrace);
+  return FiberRef.forkScopeOverride.locally(Nothing())(ma);
 }

package/_src/IO/api/interrupt.ts

@@ -1,5 +1,3 @@
-import { SetInterrupt } from "../definition.js";
-
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  *
@@ -30,7 +28,14 @@ export function setInterruptStatus_<R, E, A>(
   flag: InterruptStatus,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new SetInterrupt(self, flag, __tsplusTrace);
+  return IO.withFiberContext((fiber) => {
+    const b = flag.toBoolean;
+    if (fiber.unsafeIsInterruptible !== b) {
+      fiber.interruptStatus.push(b);
+      fiber.unsafeRestoreInterruptStatus();
+    }
+    return self;
+  });
 }
 
 /**

package/_src/IO/api/supervised.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * Returns an IO with the behavior of this one, but where all child
+ * fibers forked in the effect are reported to the specified supervisor.
+ *
+ * @tsplus fluent fncts.io.IO supervised
+ */
+export function supervised_<R, E, A>(
+  fa: IO<R, E, A>,
+  supervisor: Supervisor<any>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return FiberRef.currentSupervisor.locally(supervisor)(fa);
+}

package/_src/IO/api.ts

@@ -1,28 +1,24 @@
+import type { FiberStatus } from "../FiberStatus.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
 import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 import type { Canceler } from "@fncts/io/IO/definition";
 
 import { identity, pipe, tuple } from "@fncts/base/data/function";
+import { Stateful } from "@fncts/io/IO/definition";
 import {
   Async,
   Chain,
   Defer,
   DeferWith,
-  Ensuring,
   Fail,
-  FiberRefModifyAll,
   Fork,
-  GetDescriptor,
-  GetInterrupt,
   IO,
   IOError,
   Logged,
   Match,
-  SetRuntimeConfig,
   Succeed,
   SucceedNow,
-  Supervise,
   Yield,
 } from "@fncts/io/IO/definition";
 
@@ -358,7 +354,7 @@ export function checkInterruptible<R, E, A>(
   f: (i: InterruptStatus) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new GetInterrupt(f, __tsplusTrace);
+  return IO.withFiberContext((fiber) => f(InterruptStatus.fromBoolean(fiber.unsafeIsInterruptible)));
 }
 
 /**
@@ -515,7 +511,7 @@ export const descriptor = descriptorWith(IO.succeedNow);
  * @tsplus static fncts.io.IOOps descriptorWith
  */
 export function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new GetDescriptor(f, __tsplusTrace);
+  return IO.withFiberContext((fiber) => f(fiber.unsafeGetDescriptor()));
 }
 
 /**
@@ -535,7 +531,10 @@ export function ensuring_<R, E, A, R1>(
   finalizer: IO<R1, never, any>,
   __tsplusTrace?: string,
 ): IO<R | R1, E, A> {
-  return new Ensuring(self, finalizer, __tsplusTrace);
+  return IO.withFiberContext((fiber) => {
+    fiber.unsafeAddFinalizer(finalizer);
+    return self;
+  });
 }
 
 /**
@@ -1801,7 +1800,7 @@ export function sandboxWith_<R, E, A, E1>(
  * @tsplus static fncts.io.IOOps setRuntimeConfig
  */
 export function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): UIO<void> {
-  return IO.defer(new SetRuntimeConfig(runtimeConfig(), __tsplusTrace));
+  return IO.withFiberContext((fiber) => IO((fiber.runtimeConfig = runtimeConfig())));
 }
 
 /**
@@ -1839,21 +1838,6 @@ export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
   return new Succeed(effect, __tsplusTrace);
 }
 
-/**
- *
- * Returns an IO with the behavior of this one, but where all child
- * fibers forked in the effect are reported to the specified supervisor.
- *
- * @tsplus fluent fncts.io.IO supervised
- */
-export function supervised_<R, E, A>(
-  fa: IO<R, E, A>,
-  supervisor: Supervisor<any>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return new Supervise(fa, supervisor);
-}
-
 /**
  * @tsplus fluent fncts.io.IO summarized
  */
@@ -2051,7 +2035,22 @@ export function updateFiberRefs(
   f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => FiberRefs,
   __tsplusTrace?: string,
 ): UIO<void> {
-  return new FiberRefModifyAll((fiberId, fiberRefs) => [undefined, f(fiberId, fiberRefs)], __tsplusTrace);
+  return IO.withFiberContext((fiber) =>
+    IO(() => {
+      const newFiberRefs = f(fiber.fiberId, FiberRefs(fiber.fiberRefLocals.get));
+      fiber.fiberRefLocals.set(newFiberRefs.fiberRefLocals);
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps withFiberContext
+ */
+export function withFiberContext<R, E, A>(
+  onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return new Stateful(onState, __tsplusTrace);
 }
 
 /**

package/_src/IO/definition.ts

@@ -1,3 +1,4 @@
+import type { FiberStatus } from "../FiberStatus.js";
 import type { Trace as Trace_ } from "@fncts/base/data/Trace";
 import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 
@@ -7,7 +8,7 @@ export type IOTypeId = typeof IOTypeId;
 export interface IOF extends HKT {
   type: IO<this["R"], this["E"], this["A"]>;
   variance: {
-    R: "-";
+    R: "+";
     E: "+";
     A: "+";
   };
@@ -66,22 +67,9 @@ export const enum IOTag {
   Fail = "Fail",
   Yield = "Yield",
   Race = "Race",
-  SetInterrupt = "SetInterrupt",
-  GetInterrupt = "GetInterrupt",
-  GetDescriptor = "GetDescriptor",
-  Supervise = "Supervise",
-  FiberRefModify = "FiberRefModify",
-  FiberRefLocally = "FiberRefLocally",
-  FiberRefDelete = "FiberRefDelete",
-  FiberRefWith = "FiberRefWith",
-  FiberRefModifyAll = "FiberRefModifyAll",
-  GetForkScope = "GetForkScope",
-  OverrideForkScope = "OverrideForkScope",
   Trace = "Trace",
-  GetRuntimeConfig = "GetRuntimeConfig",
-  Ensuring = "Ensuring",
   Logged = "Logged",
-  SetRuntimeConfig = "SetRuntimeConfig",
+  Stateful = "Stateful",
 }
 
 export function isIO(u: unknown): u is IO<any, any, any> {
@@ -236,134 +224,16 @@ export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1
   }
 }
 
-/**
- * @internal
- */
-export class SetInterrupt<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.SetInterrupt;
-
-  constructor(readonly io: IO<R, E, A>, readonly flag: InterruptStatus, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetInterrupt<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetInterrupt;
-
-  constructor(readonly f: (_: InterruptStatus) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetDescriptor<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetDescriptor;
-
-  constructor(readonly f: (_: FiberDescriptor) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class Supervise<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Supervise;
-
-  constructor(readonly io: IO<R, E, A>, readonly supervisor: Supervisor<any>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class FiberRefModify<A, B> extends IO<never, never, B> {
-  readonly _tag = IOTag.FiberRefModify;
-
-  constructor(readonly fiberRef: FiberRef<unknown>, readonly f: (a: A) => readonly [B, A], readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefLocally<V, R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.FiberRefLocally;
+export class Stateful<R, E, A> extends IO<R, E, A> {
+  readonly _tag = IOTag.Stateful;
   constructor(
-    readonly localValue: V,
-    readonly fiberRef: FiberRef<V>,
-    readonly io: IO<R, E, A>,
+    readonly onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
     readonly trace?: string,
   ) {
     super();
   }
 }
 
-export class FiberRefDelete extends IO<never, never, void> {
-  readonly _tag = IOTag.FiberRefDelete;
-  constructor(readonly fiberRef: FiberRef<unknown>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefWith<A, P, R, E, B> extends IO<R, E, B> {
-  readonly _tag = IOTag.FiberRefWith;
-  constructor(readonly fiberRef: FiberRef<A>, readonly f: (a: A) => IO<R, E, B>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefModifyAll<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.FiberRefModifyAll;
-  constructor(
-    readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs],
-    readonly trace?: string,
-  ) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetForkScope<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetForkScope;
-
-  constructor(readonly f: (_: FiberScope) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class OverrideForkScope<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.OverrideForkScope;
-
-  constructor(readonly io: IO<R, E, A>, readonly forkScope: Maybe<FiberScope>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class GetRuntimeConfig<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetRuntimeConfig;
-
-  constructor(readonly f: (_: RuntimeConfig) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class Ensuring<R, E, A, R1> extends IO<R | R1, E, A> {
-  readonly _tag = IOTag.Ensuring;
-  constructor(readonly io: IO<R, E, A>, readonly finalizer: IO<R1, never, any>, readonly trace?: string) {
-    super();
-  }
-}
-
 export class Logged extends IO<never, never, void> {
   readonly _tag = IOTag.Logged;
   constructor(
@@ -378,13 +248,6 @@ export class Logged extends IO<never, never, void> {
   }
 }
 
-export class SetRuntimeConfig extends IO<never, never, void> {
-  readonly _tag = IOTag.SetRuntimeConfig;
-  constructor(readonly runtimeConfig: RuntimeConfig, readonly trace?: string) {
-    super();
-  }
-}
-
 export type Instruction =
   | Chain<any, any, any, any, any, any>
   | SucceedNow<any>
@@ -393,27 +256,14 @@ export type Instruction =
   | Async<any, any, any, any>
   | Match<any, any, any, any, any, any, any, any, any>
   | Fork<any, any, any>
-  | SetInterrupt<any, any, any>
-  | GetInterrupt<any, any, any>
   | Fail<any>
-  | GetDescriptor<any, any, any>
   | Yield
   | Defer<any, any, any>
   | DeferWith<any, any, any>
-  | FiberRefModify<any, any>
-  | FiberRefLocally<any, any, any, any>
-  | FiberRefDelete
-  | FiberRefWith<any, any, any, any, any>
-  | FiberRefModifyAll<any>
+  | Stateful<any, any, any>
   | Race<any, any, any, any, any, any, any, any, any, any, any, any>
-  | Supervise<any, any, any>
-  | GetForkScope<any, any, any>
-  | OverrideForkScope<any, any, any>
   | Trace
-  | GetRuntimeConfig<any, any, any>
-  | Ensuring<any, any, any, any>
-  | Logged
-  | SetRuntimeConfig;
+  | Logged;
 
 /**
  * @tsplus macro identity

package/_src/IO.ts

@@ -46,6 +46,7 @@ export * from "./IO/api/scopeWith.js";
 export * from "./IO/api/sequenceT.js";
 export * from "./IO/api/sleep.js";
 export * from "./IO/api/stateful.js";
+export * from "./IO/api/supervised.js";
 export * from "./IO/api/timeout.js";
 export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withEarlyRelease.js";

package/_src/Layer/api.ts

@@ -285,7 +285,7 @@ export function retry_<RIn, E, ROut, S, RIn1>(
   schedule: Schedule.WithState<S, RIn1, E, any>,
   __tsplusTrace?: string,
 ): Layer<RIn | RIn1, E, ROut> {
-  const tag = Tag<{ readonly state: S }>();
+  const tag = Tag<{ readonly state: S }>("fncts.io.Layer.retryState");
   return Layer.succeedNow({ state: schedule.initial }, tag).flatMap((environment) =>
     retryLoop(self, schedule, environment.get(tag).state, tag),
   );

package/_src/Random/definition.ts

@@ -3,7 +3,7 @@ import type { ArrayInt } from "@fncts/base/util/rand";
 /**
  * @tsplus static fncts.io.RandomOps Tag
  */
-export const RandomTag = Tag<Random>();
+export const RandomTag = Tag<Random>("fncts.io.Random");
 
 /**
  * @tsplus type fncts.io.Random

package/_src/Scope/definition.ts

@@ -28,4 +28,4 @@ export declare namespace Scope {
 /**
  * @tsplus static fncts.io.ScopeOps Tag
  */
-export const ScopeTag = Tag<Scope>();
+export const ScopeTag = Tag<Scope>("fncts.io.Scope");

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.15",
+  "version": "0.0.18",
   "dependencies": {
-    "@fncts/base": "0.0.15",
-    "@fncts/typelevel": "0.0.12"
+    "@fncts/base": "0.0.18",
+    "@fncts/transformers": "0.0.2",
+    "@fncts/typelevel": "0.0.14"
   },
   "exports": {
     "./*": {