@fncts/io 0.0.11 → 0.0.14

package/_src/IO/definition.ts

@@ -4,7 +4,14 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 export const IOTypeId = Symbol.for("fncts.io.IO");
 export type IOTypeId = typeof IOTypeId;
 
-export interface IOF extends IO<any, any, any> {}
+export interface IOF extends HKT {
+  type: IO<this["R"], this["E"], this["A"]>;
+  variance: {
+    R: "-";
+    E: "+";
+    A: "+";
+  };
+}
 
 /**
  * @tsplus type fncts.io.IO
@@ -12,11 +19,9 @@ export interface IOF extends IO<any, any, any> {}
  */
 export abstract class IO<R, E, A> {
   readonly _typeId: IOTypeId = IOTypeId;
-  readonly [HKT.F]!: IOF;
-  readonly [HKT.R]!: (_: R) => void;
-  readonly [HKT.E]!: () => E;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: IO<HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+  declare _R: () => R;
+  declare _E: () => E;
+  declare _A: () => A;
 }
 
 /**
@@ -35,18 +40,18 @@ export const IOAspects: IOAspects = {};
 export function unifyIO<X extends IO<any, any, any>>(
   self: X,
 ): IO<
-  [X] extends [IO<infer R, any, any>] ? R : never,
-  [X] extends [IO<any, infer E, any>] ? E : never,
-  [X] extends [IO<any, any, infer A>] ? A : never
+  [X] extends [{ _R: () => infer R }] ? R : never,
+  [X] extends [{ _E: () => infer E }] ? E : never,
+  [X] extends [{ _A: () => infer A }] ? A : never
 > {
   return self;
 }
 
-export type UIO<A> = IO<unknown, never, A>;
+export type UIO<A> = IO<never, never, A>;
 
 export type URIO<R, A> = IO<R, never, A>;
 
-export type FIO<E, A> = IO<unknown, E, A>;
+export type FIO<E, A> = IO<never, E, A>;
 
 export const enum IOTag {
   SucceedNow = "SucceedNow",
@@ -86,7 +91,7 @@ export function isIO(u: unknown): u is IO<any, any, any> {
 /**
  * @internal
  */
-export class Chain<R, R1, E, E1, A, A1> extends IO<R & R1, E | E1, A1> {
+export class Chain<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
   readonly _tag = IOTag.Chain;
   constructor(readonly io: IO<R, E, A>, readonly f: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
     super();
@@ -96,7 +101,7 @@ export class Chain<R, R1, E, E1, A, A1> extends IO<R & R1, E | E1, A1> {
 /**
  * @internal
  */
-export class SucceedNow<A> extends IO<unknown, never, A> {
+export class SucceedNow<A> extends IO<never, never, A> {
   readonly _tag = IOTag.SucceedNow;
   constructor(readonly value: A, readonly trace?: string) {
     super();
@@ -106,21 +111,21 @@ export class SucceedNow<A> extends IO<unknown, never, A> {
 /**
  * @internal
  */
-export class Succeed<A> extends IO<unknown, never, A> {
+export class Succeed<A> extends IO<never, never, A> {
   readonly _tag = IOTag.Succeed;
   constructor(readonly effect: () => A, readonly trace?: string) {
     super();
   }
 }
 
-export class SucceedWith<A> extends IO<unknown, never, A> {
+export class SucceedWith<A> extends IO<never, never, A> {
   readonly _tag = IOTag.SucceedWith;
   constructor(readonly effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A, readonly trace?: string) {
     super();
   }
 }
 
-export class Trace extends IO<unknown, never, Trace_> {
+export class Trace extends IO<never, never, Trace_> {
   readonly _tag = IOTag.Trace;
   constructor(readonly trace?: string) {
     super();
@@ -130,7 +135,7 @@ export class Trace extends IO<unknown, never, Trace_> {
 /**
  * @internal
  */
-export class Async<R, E, A, R1> extends IO<R & R1, E, A> {
+export class Async<R, E, A, R1> extends IO<R | R1, E, A> {
   readonly _tag = IOTag.Async;
   constructor(
     readonly register: (f: (_: IO<R, E, A>) => void) => Either<Canceler<R1>, IO<R, E, A>>,
@@ -144,7 +149,7 @@ export class Async<R, E, A, R1> extends IO<R & R1, E, A> {
 /**
  * @internal
  */
-export class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R & R1 & R2, E1 | E2, B | C> {
+export class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
   readonly _tag = IOTag.Match;
 
   constructor(
@@ -173,7 +178,7 @@ export class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
 /**
  * @internal
  */
-export class Fail<E> extends IO<unknown, E, never> {
+export class Fail<E> extends IO<never, E, never> {
   readonly _tag = IOTag.Fail;
 
   constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
@@ -184,7 +189,7 @@ export class Fail<E> extends IO<unknown, E, never> {
 /**
  * @internal
  */
-export class Yield extends IO<unknown, never, void> {
+export class Yield extends IO<never, never, void> {
   readonly _tag = IOTag.Yield;
 
   constructor(readonly trace?: string) {
@@ -217,7 +222,7 @@ export class DeferWith<R, E, A> extends IO<R, E, A> {
 /**
  * @internal
  */
-export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
   readonly _tag = "Race";
 
   constructor(
@@ -278,7 +283,7 @@ export class Supervise<R, E, A> extends IO<R, E, A> {
 /**
  * @internal
  */
-export class FiberRefModify<A, B> extends IO<unknown, never, B> {
+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) {
@@ -298,7 +303,7 @@ export class FiberRefLocally<V, R, E, A> extends IO<R, E, A> {
   }
 }
 
-export class FiberRefDelete extends IO<unknown, never, void> {
+export class FiberRefDelete extends IO<never, never, void> {
   readonly _tag = IOTag.FiberRefDelete;
   constructor(readonly fiberRef: FiberRef<unknown>, readonly trace?: string) {
     super();
@@ -312,7 +317,7 @@ export class FiberRefWith<A, P, R, E, B> extends IO<R, E, B> {
   }
 }
 
-export class FiberRefModifyAll<A> extends IO<unknown, never, A> {
+export class FiberRefModifyAll<A> extends IO<never, never, A> {
   readonly _tag = IOTag.FiberRefModifyAll;
   constructor(
     readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs],
@@ -352,14 +357,14 @@ export class GetRuntimeConfig<R, E, A> extends IO<R, E, A> {
   }
 }
 
-export class Ensuring<R, E, A, R1> extends IO<R & R1, E, A> {
+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<unknown, never, void> {
+export class Logged extends IO<never, never, void> {
   readonly _tag = IOTag.Logged;
   constructor(
     readonly message: () => string,
@@ -373,7 +378,7 @@ export class Logged extends IO<unknown, never, void> {
   }
 }
 
-export class SetRuntimeConfig extends IO<unknown, never, void> {
+export class SetRuntimeConfig extends IO<never, never, void> {
   readonly _tag = IOTag.SetRuntimeConfig;
   constructor(readonly runtimeConfig: RuntimeConfig, readonly trace?: string) {
     super();

package/_src/IO/runtime.ts

@@ -4,21 +4,16 @@ import { FiberContext } from "@fncts/io/Fiber";
 import { concrete } from "@fncts/io/IO/definition";
 import { IOEnv } from "@fncts/io/IOEnv/definition";
 
+import { StagedScheduler } from "../internal/Scheduler.js";
+
 export class Runtime<R> {
   constructor(readonly environment: Environment<R>, readonly runtimeConfig: RuntimeConfig) {}
 
-  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 fiberId = FiberId.unsafeMake(TraceElement.parse(__tsplusTrace));
-
-    const children = new Set<FiberContext<any, any>>();
-
+  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberContext<E, A> => {
+    const fiberId    = FiberId.unsafeMake(TraceElement.parse(__tsplusTrace));
+    const children   = new Set<FiberContext<any, any>>();
     const supervisor = this.runtimeConfig.supervisor;
-
-    const context = new FiberContext<E, A>(
+    const context    = new FiberContext<E, A>(
       fiberId,
       this.runtimeConfig,
       Stack.single(InterruptStatus.interruptible.toBoolean),
@@ -41,6 +36,15 @@ export class Runtime<R> {
 
     context.nextIO = concrete(io);
     context.run();
+    return context;
+  };
+
+  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 context = this.unsafeRunFiber(io);
     context.unsafeOnDone((exit) => k(exit.flatten));
     return (fiberId) => (k) => this.unsafeRunAsyncWith(context.interruptAs(fiberId), (exit) => k(exit.flatten));
   };
@@ -57,6 +61,46 @@ export class Runtime<R> {
     new Promise((resolve) => {
       this.unsafeRunAsyncWith(io, resolve);
     });
+
+  unsafeRunSyncExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+    const fiberId    = FiberId.unsafeMake(TraceElement.parse(__tsplusTrace));
+    const children   = new Set<FiberContext<any, any>>();
+    const supervisor = this.runtimeConfig.supervisor;
+    const scheduler  = new StagedScheduler();
+    const context    = new FiberContext<E, A>(
+      fiberId,
+      this.runtimeConfig,
+      Stack.single(InterruptStatus.interruptible.toBoolean),
+      new AtomicReference(
+        HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
+          [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
+          [IOEnv.services, Cons([fiberId, IOEnv.environment])],
+          [FiberRef.currentScheduler, Cons([fiberId, scheduler])],
+        ),
+      ),
+      children,
+    );
+
+    FiberScope.global.unsafeAdd(context);
+
+    if (supervisor !== Supervisor.none) {
+      supervisor.unsafeOnStart(this.environment, io, Nothing(), context);
+
+      context.unsafeOnDone((exit) => supervisor.unsafeOnEnd(exit.flatten, context));
+    }
+
+    context.nextIO = concrete(io);
+    context.run();
+    scheduler.flush();
+
+    const result = context.unsafePoll();
+
+    if (result.isJust()) {
+      return result.value;
+    }
+
+    return Exit.halt(context);
+  };
 }
 
 /**
@@ -70,7 +114,7 @@ export function runtime<R>(__tsplusTrace?: string): URIO<R, Runtime<R>> {
 
 export const defaultRuntimeConfig = new RuntimeConfig({
   reportFailure: () => undefined,
-  supervisor: Supervisor.unsafeTrack(),
+  supervisor: Supervisor.unsafeTrack(true),
   flags: RuntimeConfigFlags.empty,
   yieldOpCount: 2048,
   logger: Logger.defaultString.map((s) => console.log(s)).filterLogLevel((level) => level >= LogLevel.Info),
@@ -78,6 +122,11 @@ export const defaultRuntimeConfig = new RuntimeConfig({
 
 export const defaultRuntime = new Runtime(Environment.empty, defaultRuntimeConfig);
 
+/**
+ * @tsplus fluent fncts.io.IO unsafeRunFiber
+ */
+export const unsafeRunFiber = defaultRuntime.unsafeRunFiber;
+
 /**
  * @tsplus fluent fncts.io.IO unsafeRunAsync
  */
@@ -97,3 +146,8 @@ export const unsafeRunPromiseExit = defaultRuntime.unsafeRunPromiseExit;
  * @tsplus fluent fncts.io.IO unsafeRunWith
  */
 export const unsafeRunWith = defaultRuntime.unsafeRunWith;
+
+/**
+ * @tsplus getter fncts.io.IO unsafeRunSyncExit
+ */
+export const unsafeRunSyncExit = defaultRuntime.unsafeRunSyncExit;

package/_src/IOEnv/definition.ts

@@ -2,7 +2,7 @@ import type { Patch } from "@fncts/base/data/Patch";
 
 import { Console } from "@fncts/io/Console";
 
-export type IOEnv = Has<Clock> & Has<Console> & Has<Random>;
+export type IOEnv = Clock | Console | Random;
 
 /**
  * @tsplus type fncts.io.IOEnvOps

package/_src/Layer/MemoMap.ts

@@ -14,9 +14,8 @@ export class MemoMap {
    * returns it. Otherwise, obtains the dependency, stores it in the memo map,
    * and adds a finalizer to the outer `Managed`.
    */
-  getOrElseMemoize = <R, E, A>(scope: Scope, layer: Layer<R, E, A>) => {
+  getOrElseMemoize = <R, E, A>(scope: Scope, layer: Layer<R, E, A>, __tsplusTrace?: string) => {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
     return this.ref.modifyIO((map) => {
       const inMap = map.get(layer[LayerHash]);
 
@@ -32,35 +31,34 @@ export class MemoMap {
 
         return IO.succeedNow(tuple(cached, map));
       } else {
-        return IO.gen(function* (_) {
-          const observers    = yield* _(Ref.make(0));
-          const future       = yield* _(Future.make<E, Environment<A>>());
-          const finalizerRef = yield* _(Ref.make<Finalizer>(Finalizer.noop));
+        return Do((_) => {
+          const observers    = _(Ref.make(0));
+          const future       = _(Future.make<E, Environment<A>>());
+          const finalizerRef = _(Ref.make<Finalizer>(Finalizer.noop));
 
           const resource = IO.uninterruptibleMask(({ restore }) =>
-            IO.gen(function* (_) {
-              const environment = yield* _(IO.environment<R>());
-              const outerScope  = scope;
-              const innerScope  = yield* _(Scope.make);
+            Do((_) => {
+              const outerScope = scope;
+              const innerScope = _(Scope.make);
 
-              const tp = yield* _(
-                restore(layer.scope(innerScope).flatMap((f) => f(self))).result.flatMap((exit) =>
+              const tp = _(
+                restore(layer.scope(innerScope).flatMap((f) => f(this))).result.flatMap((exit) =>
                   exit.match(
                     (cause) => future.failCause(cause) > innerScope.close(exit) > IO.failCauseNow(cause),
                     (a) =>
-                      IO.gen(function* (_) {
-                        yield* _(
+                      Do((_) => {
+                        _(
                           finalizerRef
                             .set(Finalizer.get((exit) => innerScope.close(exit)))
                             .whenIO(observers.modify((n) => [n === 1, n - 1])),
                         );
-                        yield* _(observers.update((n) => n + 1));
-                        yield* _(
+                        _(observers.update((n) => n + 1));
+                        _(
                           outerScope.addFinalizerExit(
                             Finalizer.get((e) => finalizerRef.get.flatMap((fin) => Finalizer.reverseGet(fin)(e))),
                           ),
                         );
-                        yield* _(future.succeed(a));
+                        _(future.succeed(a));
                         return a;
                       }),
                   ),
@@ -95,7 +93,7 @@ export function isFresh<R, E, A>(self: Layer<R, E, A>): self is Fresh<R, E, A> {
   return self._tag === LayerTag.Fresh;
 }
 
-export function makeMemoMap(): UIO<MemoMap> {
+export function makeMemoMap(__tsplusTrace?: string): UIO<MemoMap> {
   return Ref.Synchronized.make(HashMap.makeDefault<PropertyKey, readonly [FIO<any, any>, Finalizer]>()).flatMap((ref) =>
     IO.succeedNow(new MemoMap(ref)),
   );
@@ -104,18 +102,18 @@ export function makeMemoMap(): UIO<MemoMap> {
 /**
  * @tsplus getter fncts.io.Layer build
  */
-export function build<R, E, A>(self: Layer<R, E, A>): IO<R & Has<Scope>, E, Environment<A>> {
+export function build<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, Environment<A>> {
   return IO.serviceWithIO((scope: Scope) => self.build(scope), Scope.Tag);
 }
 
 /**
  * @tsplus fluent fncts.io.Layer build
  */
-export function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope): IO<R, E, Environment<A>> {
-  return IO.gen(function* (_) {
-    const memoMap = yield* _(makeMemoMap());
-    const run     = yield* _(self.scope(scope));
-    return yield* _(run(memoMap));
+export function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<R, E, Environment<A>> {
+  return Do((_) => {
+    const memoMap = _(makeMemoMap());
+    const run     = _(self.scope(scope));
+    return _(run(memoMap));
   });
 }
 
@@ -125,45 +123,54 @@ export function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope): IO<R, E, En
 export function scope<R, E, A>(
   layer: Layer<R, E, A>,
   scope: Scope,
-): IO<unknown, never, (_: MemoMap) => IO<R, E, Environment<A>>> {
+  __tsplusTrace?: string,
+): IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>> {
   layer.concrete();
   switch (layer._tag) {
     case LayerTag.Fold: {
       return IO.succeed(
         () => (memoMap: MemoMap) =>
-          memoMap.getOrElseMemoize(scope, layer.self).matchCauseIO(
-            (cause) => memoMap.getOrElseMemoize(scope, layer.failure(cause)),
+          memoMap.getOrElseMemoize(scope, layer.self, layer.trace).matchCauseIO(
+            (cause) => memoMap.getOrElseMemoize(scope, layer.failure(cause), layer.trace),
             (r) => memoMap.getOrElseMemoize(scope, layer.success(r)),
+            layer.trace,
           ),
       );
     }
     case LayerTag.Fresh: {
-      return IO.succeed(() => () => layer.self.build(scope));
+      return IO.succeed(() => () => layer.self.build(scope, layer.trace));
     }
     case LayerTag.Scoped: {
-      return IO.succeed(() => () => scope.extend(layer.self));
+      return IO.succeed(() => () => scope.extend(layer.self, layer.trace));
     }
     case LayerTag.Defer: {
-      return IO.succeed(() => (memoMap: MemoMap) => memoMap.getOrElseMemoize(scope, layer.self()));
+      return IO.succeed(() => (memoMap: MemoMap) => memoMap.getOrElseMemoize(scope, layer.self(), layer.trace));
     }
     case LayerTag.To: {
       return IO.succeed(
         () => (memoMap: MemoMap) =>
           memoMap
-            .getOrElseMemoize(scope, layer.self)
-            .flatMap((r) => memoMap.getOrElseMemoize(scope, layer.that).provideEnvironment(r)),
+            .getOrElseMemoize(scope, layer.self, layer.trace)
+            .flatMap(
+              (r) => memoMap.getOrElseMemoize(scope, layer.that, layer.trace).provideEnvironment(r),
+              layer.trace,
+            ),
       );
     }
     case LayerTag.ZipWith: {
       return IO.succeed(
         () => (memoMap: MemoMap) =>
-          memoMap.getOrElseMemoize(scope, layer.self).zipWith(memoMap.getOrElseMemoize(scope, layer.that), layer.f),
+          memoMap
+            .getOrElseMemoize(scope, layer.self, layer.trace)
+            .zipWith(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
       );
     }
     case LayerTag.ZipWithC: {
       return IO.succeed(
         () => (memoMap: MemoMap) =>
-          memoMap.getOrElseMemoize(scope, layer.self).zipWithC(memoMap.getOrElseMemoize(scope, layer.that), layer.f),
+          memoMap
+            .getOrElseMemoize(scope, layer.self, layer.trace)
+            .zipWithC(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
       );
     }
   }