@fncts/io 0.0.2 → 0.0.5

package/_src/FiberRef/constructors.ts

@@ -1,8 +1,4 @@
-import type { LogSpan } from "@fncts/io/LogSpan";
-
 import { identity } from "@fncts/base/data/function";
-import { Patch } from "@fncts/base/data/Patch";
-import { FiberRefInternal } from "@fncts/io/FiberRef/definition";
 
 function makeWith<Value, Patch>(
   ref: Lazy<FiberRef.WithPatch<Value, Patch>>,
@@ -13,49 +9,6 @@ function makeWith<Value, Patch>(
   );
 }
 
-/**
- * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
- */
-export function unsafeMakePatch<Value, Patch>(
-  initial: Value,
-  diff: (oldValue: Value, newValue: Value) => Patch,
-  combine: (first: Patch, second: Patch) => Patch,
-  patch: (patch: Patch) => (oldValue: Value) => Value,
-  fork: Patch,
-): FiberRef.WithPatch<Value, Patch> {
-  return new FiberRefInternal(initial, diff, combine, patch, fork);
-}
-
-/**
- * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
- */
-export function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Patch<A, A>> {
-  return FiberRef.unsafeMakePatch(
-    initial,
-    Patch.diff,
-    (first, second) => first.compose(second),
-    (patch) => (value) => patch(value),
-    Patch.empty(),
-  );
-}
-
-/**
- * @tsplus static fncts.io.FiberRefOps unsafeMake
- */
-export function unsafeMake<A>(
-  initial: A,
-  fork: (a: A) => A = identity,
-  join: (a0: A, a1: A) => A = (_, a) => a,
-): FiberRef.WithPatch<A, (_: A) => A> {
-  return FiberRef.unsafeMakePatch(
-    initial,
-    (_, newValue) => () => newValue,
-    (first, second) => (value) => second(first(value)),
-    (patch) => (value) => join(value, patch(value)),
-    fork,
-  );
-}
-
 /**
  * @tsplus static fncts.io.FiberRefOps make
  */
@@ -64,35 +17,5 @@ export function make<A>(
   fork: (a: A) => A = identity,
   join: (a: A, a1: A) => A = (_, a) => a,
 ): IO<Has<Scope>, never, FiberRef<A>> {
-  return makeWith(unsafeMake(initial, fork, join));
+  return makeWith(FiberRef.unsafeMake(initial, fork, join));
 }
-
-/**
- * @tsplus static fncts.io.FiberRefOps forkScopeOverride
- */
-export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(Nothing());
-
-/**
- * @tsplus static fncts.io.FiberRefOps currentEnvironment
- */
-export const currentEnvironment = FiberRef.unsafeMakeEnvironment<unknown>(Environment.empty);
-
-/**
- * @tsplus static fncts.io.FiberRefOps fiberName
- */
-export const fiberName = FiberRef.unsafeMake<Maybe<string>>(Nothing());
-
-/**
- * @tsplus static fncts.io.FiberRefOps currentLogLevel
- */
-export const currentLogLevel = FiberRef.unsafeMake<LogLevel>(LogLevel.Info);
-
-/**
- * @tsplus static fncts.io.FiberRefOps currentLogSpan
- */
-export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
-
-/**
- * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
- */
-export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());

package/_src/FiberRef/unsafe.ts

@@ -0,0 +1,79 @@
+import type { LogSpan } from "../LogSpan.js";
+
+import { identity } from "@fncts/base/data/function";
+import { Patch } from "@fncts/base/data/Patch";
+
+import { FiberRefInternal } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
+ */
+export function unsafeMakePatch<Value, Patch>(
+  initial: Value,
+  diff: (oldValue: Value, newValue: Value) => Patch,
+  combine: (first: Patch, second: Patch) => Patch,
+  patch: (patch: Patch) => (oldValue: Value) => Value,
+  fork: Patch,
+): FiberRef.WithPatch<Value, Patch> {
+  return new FiberRefInternal(initial, diff, combine, patch, fork);
+}
+
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
+ */
+export function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Patch<A, A>> {
+  return FiberRef.unsafeMakePatch(
+    initial,
+    Patch.diff,
+    (first, second) => first.compose(second),
+    (patch) => (value) => patch(value),
+    Patch.empty(),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMake
+ */
+export function unsafeMake<A>(
+  initial: A,
+  fork: (a: A) => A = identity,
+  join: (a0: A, a1: A) => A = (_, a) => a,
+): FiberRef.WithPatch<A, (_: A) => A> {
+  return FiberRef.unsafeMakePatch(
+    initial,
+    (_, newValue) => () => newValue,
+    (first, second) => (value) => second(first(value)),
+    (patch) => (value) => join(value, patch(value)),
+    fork,
+  );
+}
+
+/**
+ * @tsplus static fncts.io.FiberRefOps forkScopeOverride
+ */
+export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(Nothing(), () => Nothing());
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentEnvironment
+ */
+export const currentEnvironment = FiberRef.unsafeMakeEnvironment<unknown>(Environment.empty);
+
+/**
+ * @tsplus static fncts.io.FiberRefOps fiberName
+ */
+export const fiberName = FiberRef.unsafeMake<Maybe<string>>(Nothing());
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogLevel
+ */
+export const currentLogLevel = FiberRef.unsafeMake<LogLevel>(LogLevel.Info);
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogSpan
+ */
+export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
+ */
+export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());

package/_src/FiberRef.ts

@@ -2,6 +2,7 @@
 export * from "./FiberRef/api.js";
 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 }

package/_src/FiberRefs/join.ts

@@ -40,8 +40,8 @@ export function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs)
 }
 
 function compareFiberId(left: FiberId.Runtime, right: FiberId.Runtime): number {
-  const compare = Number.Ord.compare_(left.startTime, right.startTime);
-  return compare === 0 ? Number.Ord.compare_(left.id, right.id) : compare;
+  const compare = Number.Ord.compare(left.startTime, right.startTime);
+  return compare === 0 ? Number.Ord.compare(left.id, right.id) : compare;
 }
 
 /**

package/_src/Future/constructors.ts

@@ -1,4 +1,4 @@
-import { Pending } from "@fncts/io/Future/definition";
+import { Future, Pending } from "@fncts/io/Future/definition";
 
 /**
  * Makes a new future to be completed by the fiber creating the future.

package/_src/IO/api/asyncIO.ts

@@ -0,0 +1,16 @@
+/**
+ * @tsplus static fncts.io.IOOps asyncIO
+ */
+export function asyncIO<R, E, A>(register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>): IO<R, E, A> {
+  return Do((Δ) => {
+    const f = Δ(Future.make<E, A>());
+    const r = Δ(IO.runtime<R>());
+    const a = Δ(
+      IO.uninterruptibleMask(({ restore }) => {
+        const io = register((k) => r.unsafeRunAsync(k.fulfill(f)));
+        return restore(io.catchAllCause((cause) => f.failCause(cause))).fork > restore(f.await);
+      }),
+    );
+    return a;
+  });
+}

package/_src/IO/api/ensuringChildren.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus fluent fncts.io.IO ensuringChildren
+ */
+export function ensuringChildren<R, E, A, R1>(
+  self: IO<R, E, A>,
+  children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>,
+): IO<R & R1, E, A> {
+  return Supervisor.track.flatMap((supervisor) =>
+    self.supervised(supervisor).ensuring(supervisor.value.flatMap(children)),
+  );
+}

package/_src/IO/api/interrupt.ts

@@ -100,7 +100,8 @@ export function onInterrupt_<R, E, A, R1>(
 ): IO<R & R1, E, A> {
   return uninterruptibleMask(({ restore }) =>
     restore(ma).matchCauseIO(
-      (cause) => (cause.interrupted ? cleanup(cause.interruptors) : IO.failCauseNow(cause)),
+      (cause) =>
+        cause.interrupted ? cleanup(cause.interruptors).apSecond(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
       IO.succeedNow,
     ),
   );

package/_src/IO/api/sequenceT.ts

@@ -7,6 +7,6 @@ import { identity, unsafeCoerce } from "@fncts/base/data/function";
  */
 export function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(
   ...ios: T
-): IO<_R<T[number]>, _E<T[number]>, { [K in keyof T]: _A<T[K]> }> {
+): IO<HKT._R<T[number]>, HKT._E<T[number]>, { [K in keyof T]: HKT._A<T[K]> }> {
   return unsafeCoerce(IO.foreach(ios, identity));
 }

package/_src/IO/api/sleep.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps sleep
  */
-export function sleep(duration: number, __tsplusTrace?: string): UIO<void> {
+export function sleep(duration: Lazy<Duration>, __tsplusTrace?: string): UIO<void> {
   return Clock.sleep(duration);
 }

package/_src/IO/api/timeout.ts

@@ -0,0 +1,19 @@
+/**
+ * @tsplus fluent fncts.io.IO timeoutTo
+ */
+export function timeoutTo<R, E, A, B, B1>(
+  self: IO<R, E, A>,
+  duration: Lazy<Duration>,
+  b: Lazy<B>,
+  f: (a: A) => B1,
+  __tsplusTrace?: string,
+): IO<R, E, B | B1> {
+  return self.map(f).raceFirst(IO.sleep(duration).interruptible.as(b));
+}
+
+/**
+ * @tsplus fluent fncts.io.IO timeout
+ */
+export function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>): IO<R, E, Maybe<A>> {
+  return self.timeoutTo(duration, Nothing(), Maybe.just);
+}

package/_src/IO/api.ts

@@ -761,12 +761,14 @@ export function foldLeft_<A, B, R, E>(
 /**
  * Combines an array of `IO`s using a `Monoid`
  *
- * @constrained
  * @tsplus static fncts.io.IOOps foldMap
  */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <R, E, A>(as: Iterable<IO<R, E, A>>, f: (a: A) => M): IO<R, E, M> =>
-    IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine_(m, f(a))));
+export function foldMap_<R, E, A, M>(
+  as: Iterable<IO<R, E, A>>,
+  f: (a: A) => M,
+  /** @tsplus auto */ M: P.Monoid<M>,
+): IO<R, E, M> {
+  return IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine(m, f(a))));
 }
 
 function foldRightLoop<A, B, R, E>(

package/_src/IO/definition.ts

@@ -4,15 +4,19 @@ 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> {}
+
 /**
  * @tsplus type fncts.io.IO
  * @tsplus companion fncts.io.IOOps
  */
 export abstract class IO<R, E, A> {
   readonly _typeId: IOTypeId = IOTypeId;
-  readonly _R!: (_: R) => void;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  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>>;
 }
 
 /**
@@ -407,7 +411,7 @@ export type Instruction =
   | SetRuntimeConfig;
 
 /**
- * @optimize identity
+ * @tsplus macro identity
  */
 export function concrete(_: IO<any, any, any>): Instruction {
   // @ts-expect-error

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/asyncIO.js";
 export * from "./IO/api/bracket.js";
 export * from "./IO/api/bracketExit.js";
 export * from "./IO/api/clockWith.js";
@@ -18,6 +19,7 @@ export * from "./IO/api/concurrency.js";
 export * from "./IO/api/concurrentFinalizers.js";
 export * from "./IO/api/consoleWith.js";
 export * from "./IO/api/core-scope.js";
+export * from "./IO/api/ensuringChildren.js";
 export * from "./IO/api/environment.js";
 export * from "./IO/api/foreachC.js";
 export * from "./IO/api/foreachExec.js";
@@ -43,6 +45,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/timeout.js";
 export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withFinalizer.js";
 export * from "./IO/api/withFinalizerExit.js";

package/_src/InterruptStatus/constructors.ts

@@ -1,3 +1,5 @@
+import { InterruptStatus } from "./definition.js";
+
 /**
  * @tsplus static fncts.InterruptStatusOps interruptible
  */

package/_src/Layer/api.ts

@@ -282,7 +282,7 @@ function retryUpdate<S, RIn, E, X>(
         .flatMap(([state, _, decision]) =>
           decision._tag === DecisionTag.Done
             ? IO.failNow(e)
-            : Clock.sleep(decision.interval.startMilliseconds - now).as({ state }),
+            : Clock.sleep(Duration.fromInterval(now, decision.interval.startMilliseconds)).as({ state }),
         ),
     ),
     tag,

package/_src/Ref/Atomic/api.ts

@@ -29,6 +29,7 @@ export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     const o = f(v);
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }
@@ -56,6 +57,7 @@ export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<rea
     const v = self.unsafeGet;
     const o = f(v);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value[1]);
       return o.value[0];
@@ -91,6 +93,7 @@ export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }
@@ -104,6 +107,7 @@ export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }

package/_src/Schedule/Decision.ts

@@ -1,5 +1,3 @@
-import type { Interval } from "./Interval.js";
-
 export const enum DecisionTag {
   Continue = "Continue",
   Done = "Done",

package/_src/Schedule/api/driver.ts

@@ -19,7 +19,7 @@ export function driver<State, Env, In, Out>(
             (interval) =>
               ref
                 .set([Just(out), state1])
-                .apSecond(Clock.sleep(interval.startMilliseconds - now))
+                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.startMilliseconds)))
                 .as(out),
           ),
         );

package/_src/Schedule/api.ts

@@ -1,7 +1,4 @@
-import { Driver } from "@fncts/io/Schedule/Driver";
-
 import { Decision, DecisionTag } from "./Decision.js";
-import { Interval } from "./Interval.js";
 
 /**
  * @tsplus static fncts.io.ScheduleOps __call

package/_src/Schedule.ts

@@ -3,5 +3,4 @@ export * from "./Schedule/api.js";
 export * from "./Schedule/Decision.js";
 export * from "./Schedule/definition.js";
 export * from "./Schedule/Driver.js";
-export * from "./Schedule/Interval.js";
 // codegen:end

package/_src/Scope/Finalizer/definition.ts

@@ -1,5 +1,5 @@
 interface FinalizerN extends HKT {
-  readonly type: Finalizer;
+  readonly [HKT.T]: Finalizer;
 }
 
 /**

package/_src/Scope/ReleaseMap/definition.ts

@@ -15,7 +15,7 @@ export class Running {
 export type State = Exited | Running;
 
 interface ReleaseMapN extends HKT {
-  readonly type: ReleaseMap;
+  readonly [HKT.T]: ReleaseMap;
 }
 
 /**