@fncts/io 0.0.21 → 0.0.23

package/IO/api.d.ts

@@ -1,12 +1,11 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
-import { URIO, FIO, UIO } from "@fncts/io/IO/definition";
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+import { URIO, UIO, FIO } from "@fncts/io/IO/definition";
 import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
@@ -17,11 +16,11 @@ import { Trace } from "@fncts/base/data/Trace/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs";
-import type { FiberStatus } from "../FiberStatus.js";
+import type { Running } 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 type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 import { pipe } from "@fncts/base/data/function";
 import { IO } from "@fncts/io/IO/definition";
 /**
@@ -30,34 +29,6 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function async<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => void, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Imports an asynchronous effect into a pure `IO`, possibly returning the value synchronously.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called at most once.
- * @tsplus static fncts.io.IOOps asyncMaybe
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function asyncMaybe<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => Maybe<IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Imports an asynchronous side-effect into an IO. The side-effect
- * has the option of returning the value synchronously, which is useful in
- * cases where it cannot be determined if the effect is synchronous or
- * asynchronous until the side-effect is actually executed. The effect also
- * has the option of returning a canceler, which will be used by the runtime
- * to cancel the asynchronous effect if the fiber executing the effect is
- * interrupted.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called
- * at most once.
- *
- * The list of fibers, that may complete the async callback, is used to
- * provide better diagnostics.
- * @tsplus static fncts.io.IOOps asyncInterrupt
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E, A>) => void) => Either<Canceler<R>, IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Attempts to convert defects into a failure, throwing away all information
  * about the cause of the failure.
@@ -66,18 +37,18 @@ export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E
  */
 export declare function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, unknown, A>;
 /**
- * @tsplus pipeable fncts.io.IO apFirst
+ * @tsplus pipeable fncts.io.IO zipLeft
  * @tsplus pipeable-operator fncts.io.IO <
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apFirst<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
 /**
  * Combine two effectful actions, keeping only the result of the second
- * @tsplus pipeable fncts.io.IO apSecond
+ * @tsplus pipeable fncts.io.IO zipRight
  * @tsplus pipeable-operator fncts.io.IO >
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apSecond<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
+export declare function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
 /**
  * @tsplus pipeable fncts.io.IO as
  * @tsplus location "@fncts/io/IO/api"
@@ -180,6 +151,13 @@ export declare function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, import("@fncts/base/data/Cause.js").Cause<E>, A>;
+/**
+ * Checks the interrupt status, and produces the IO returned by the
+ * specified callback.
+ * @tsplus static fncts.io.IOOps checkInterruptible
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns an IO that models the execution of this effect, followed by
  * the passing of its value to the specified continuation function `f`,
@@ -193,13 +171,6 @@ export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tspl
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A>;
-/**
- * Checks the interrupt status, and produces the IO returned by the
- * specified callback.
- * @tsplus static fncts.io.IOOps checkInterruptible
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO collect
  * @tsplus location "@fncts/io/IO/api"
@@ -224,15 +195,6 @@ export declare function condIO<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFa
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Returns a lazily constructed effect, whose construction may itself require
- * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
- * it is conceptually equivalent to `flatten(effectTotal(io))`. If you wonder if the effect throws exceptions,
- * do not use this method, use `IO.deferTryCatchWith`.
- * @tsplus static fncts.io.IOOps deferWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function deferWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects.
  * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(try(io))`.
@@ -240,13 +202,6 @@ export declare function deferWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
-/**
- * Returns a lazily constructed effect, whose construction may itself require effects.
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- * @tsplus static IOOps deferTryWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -257,37 +212,21 @@ export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig,
  */
 export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
 /**
- * Returns a lazily constructed effect, whose construction may itself require effects,
- * translating any thrown exceptions into typed failed effects and mapping the error.
- *
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- * @tsplus static IOOps deferTryCatchWith
+ * @tsplus static fncts.io.IOOps descriptorWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTryCatchWith<R, E, A, E1>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
+export declare function descriptorWith<R, E, A>(f: (descriptor: FiberDescriptor) => IO<R, E, A>): IO<R, E, A>;
 /**
  * @tsplus static fncts.io.IOOps descriptor
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare const descriptor: IO<never, never, import("../FiberDescriptor.js").FiberDescriptor>;
-/**
- * Constructs an IO based on information about the current fiber, such as
- * its identity.
- * @tsplus static fncts.io.IOOps descriptorWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare const descriptor: UIO<FiberDescriptor>;
 /**
  * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
  * @tsplus getter fncts.io.IO either
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>>;
-/**
- * @tsplus pipeable fncts.io.IO ensuring
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
@@ -313,6 +252,11 @@ export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, neve
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never>;
+/**
+ * @tsplus static fncts.io.IOOps refailCause
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never>;
 /**
  * Creates a `IO` that has failed with the specified `Cause`
  * @tsplus static fncts.io.IOOps failCauseNow
@@ -331,6 +275,11 @@ export declare function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, _
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare const fiberId: IO<never, never, FiberId>;
+/**
+ * @tsplus static fncts.io.IOOps fiberIdWith
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function fiberIdWith<R, E, A>(f: (id: FiberId.Runtime) => IO<R, E, A>): IO<R, E, A>;
 /**
  * Filters the collection using the specified effectual predicate.
  * @tsplus static fncts.io.IOOps filter
@@ -444,31 +393,6 @@ export declare function foreachDiscard<A, R, E, B>(as: Iterable<A>, f: (a: A) =>
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, never>;
-/**
- * Returns an IO that forks this IO into its own separate fiber,
- * returning the fiber immediately, without waiting for it to begin executing
- * the IO.
- *
- * You can use the `fork` method whenever you want to execute an IO in a
- * new fiber, concurrently and without "blocking" the fiber executing other
- * IOs. Using fibers can be tricky, so instead of using this method
- * directly, consider other higher-level methods, such as `raceWith`,
- * `zipC`, and so forth.
- *
- * The fiber returned by this method has methods interrupt the fiber and to
- * wait for it to finish executing the IO. See `Fiber` for more
- * information.
- *
- * Whenever you use this method to launch a new fiber, the new fiber is
- * attached to the parent fiber's scope. This means when the parent fiber
- * terminates, the child fiber will be terminated as well, ensuring that no
- * fibers leak. This behavior is called "None supervision", and if this
- * behavior is not desired, you may use the `forkDaemon` or `forkIn`
- * methods.
- * @tsplus getter fncts.io.IO fork
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberContext<E, A>>;
 /**
  * Lifts an `Either` into an `IO`
  * @tsplus static fncts.io.IOOps fromEither
@@ -746,13 +670,6 @@ export declare function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function mergeAll<R, E, A, B>(fas: Iterable<IO<R, E, A>>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
-/**
- * Returns a `IO` that will never produce anything. The moral equivalent of
- * `while(true) {}`, only without the wasted CPU cycles.
- * @tsplus static fncts.io.IOOps never
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare const never: UIO<never>;
 /**
  * Converts an option on errors into an option on values.
  * @tsplus getter fncts.io.IO optional
@@ -927,12 +844,6 @@ export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: stri
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
-/**
- * Retrieves the runtimeConfig that this effect is running on.
- * @tsplus static fncts.io.IOOps runtimeConfig
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare const runtimeConfig: UIO<RuntimeConfig>;
 /**
  * Exposes the full cause of failure of this effect.
  * @tsplus getter fncts.io.IO sandbox
@@ -944,12 +855,6 @@ export declare function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function sandboxWith<R, E, A, E1>(f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, E1, A>;
-/**
- * Sets the runtime configuration to the specified value.
- * @tsplus static fncts.io.IOOps setRuntimeConfig
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): UIO<void>;
 /**
  * @tsplus static fncts.io.IOOps sequenceIterable
  * @tsplus location "@fncts/io/IO/api"
@@ -1075,11 +980,6 @@ export declare function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function updateFiberRefs(f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => FiberRefs, __tsplusTrace?: string): UIO<void>;
-/**
- * @tsplus static fncts.io.IOOps withFiberContext
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function withFiberContext<R, E, A>(onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus fluent fncts.io.IO __call
  * @tsplus location "@fncts/io/IO/api"
@@ -1096,6 +996,21 @@ export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, void>;
+/**
+ * @tsplus static fncts.io.IOOps withFiberRuntime
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function withFiberRuntime<R, E, A>(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void>;
+/**
+ * @tsplus static fncts.io.IOOps stackTrace
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function stackTrace(__tsplusTrace?: string): UIO<Trace>;
 /**
  * Returns an effect that yields to the runtime system, starting on a fresh
  * stack. Manual use of this method can improve fairness, at the cost of