Erster Docker-Stand
This commit is contained in:
831
_node_modules/effect/dist/dts/Fiber.d.ts
generated
vendored
Normal file
831
_node_modules/effect/dist/dts/Fiber.d.ts
generated
vendored
Normal file
@@ -0,0 +1,831 @@
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
import type * as Cause from "./Cause.js";
|
||||
import type { Context } from "./Context.js";
|
||||
import type { DefaultServices } from "./DefaultServices.js";
|
||||
import type * as Effect from "./Effect.js";
|
||||
import type * as Either from "./Either.js";
|
||||
import type * as Exit from "./Exit.js";
|
||||
import type * as FiberId from "./FiberId.js";
|
||||
import type { FiberRef } from "./FiberRef.js";
|
||||
import type * as FiberRefs from "./FiberRefs.js";
|
||||
import type * as FiberStatus from "./FiberStatus.js";
|
||||
import type * as HashSet from "./HashSet.js";
|
||||
import type * as Option from "./Option.js";
|
||||
import type * as order from "./Order.js";
|
||||
import type * as RuntimeFlags from "./RuntimeFlags.js";
|
||||
import type { Scheduler } from "./Scheduler.js";
|
||||
import type * as Scope from "./Scope.js";
|
||||
import type { Supervisor } from "./Supervisor.js";
|
||||
import type { AnySpan, Tracer } from "./Tracer.js";
|
||||
import type * as Types from "./Types.js";
|
||||
import type * as Unify from "./Unify.js";
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category symbols
|
||||
*/
|
||||
export declare const FiberTypeId: unique symbol;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category symbols
|
||||
*/
|
||||
export type FiberTypeId = typeof FiberTypeId;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category symbols
|
||||
*/
|
||||
export declare const RuntimeFiberTypeId: unique symbol;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category symbols
|
||||
*/
|
||||
export type RuntimeFiberTypeId = typeof RuntimeFiberTypeId;
|
||||
/**
|
||||
* A fiber is a lightweight thread of execution that never consumes more than a
|
||||
* whole thread (but may consume much less, depending on contention and
|
||||
* asynchronicity). Fibers are spawned by forking effects, which run
|
||||
* concurrently with the parent effect.
|
||||
*
|
||||
* Fibers can be joined, yielding their result to other fibers, or interrupted,
|
||||
* which terminates the fiber, safely releasing all resources.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
export interface Fiber<out A, out E = never> extends Effect.Effect<A, E>, Fiber.Variance<A, E> {
|
||||
/**
|
||||
* The identity of the fiber.
|
||||
*/
|
||||
id(): FiberId.FiberId;
|
||||
/**
|
||||
* Awaits the fiber, which suspends the awaiting fiber until the result of the
|
||||
* fiber has been determined.
|
||||
*/
|
||||
readonly await: Effect.Effect<Exit.Exit<A, E>>;
|
||||
/**
|
||||
* Retrieves the immediate children of the fiber.
|
||||
*/
|
||||
readonly children: Effect.Effect<Array<Fiber.Runtime<any, any>>>;
|
||||
/**
|
||||
* Inherits values from all `FiberRef` instances into current fiber. This
|
||||
* will resume immediately.
|
||||
*/
|
||||
readonly inheritAll: Effect.Effect<void>;
|
||||
/**
|
||||
* Tentatively observes the fiber, but returns immediately if it is not
|
||||
* already done.
|
||||
*/
|
||||
readonly poll: Effect.Effect<Option.Option<Exit.Exit<A, E>>>;
|
||||
/**
|
||||
* In the background, interrupts the fiber as if interrupted from the
|
||||
* specified fiber. If the fiber has already exited, the returned effect will
|
||||
* resume immediately. Otherwise, the effect will resume when the fiber exits.
|
||||
*/
|
||||
interruptAsFork(fiberId: FiberId.FiberId): Effect.Effect<void>;
|
||||
readonly [Unify.typeSymbol]?: unknown;
|
||||
readonly [Unify.unifySymbol]?: FiberUnify<this>;
|
||||
readonly [Unify.ignoreSymbol]?: FiberUnifyIgnore;
|
||||
}
|
||||
/**
|
||||
* @category models
|
||||
* @since 3.8.0
|
||||
*/
|
||||
export interface FiberUnify<A extends {
|
||||
[Unify.typeSymbol]?: any;
|
||||
}> extends Effect.EffectUnify<A> {
|
||||
Fiber?: () => A[Unify.typeSymbol] extends Fiber<infer A0, infer E0> | infer _ ? Fiber<A0, E0> : never;
|
||||
}
|
||||
/**
|
||||
* @category models
|
||||
* @since 3.8.0
|
||||
*/
|
||||
export interface FiberUnifyIgnore extends Effect.EffectUnifyIgnore {
|
||||
Effect?: true;
|
||||
}
|
||||
/**
|
||||
* A runtime fiber that is executing an effect. Runtime fibers have an
|
||||
* identity and a trace.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
export interface RuntimeFiber<out A, out E = never> extends Fiber<A, E>, Fiber.RuntimeVariance<A, E> {
|
||||
/**
|
||||
* Reads the current number of ops that have occurred since the last yield
|
||||
*/
|
||||
get currentOpCount(): number;
|
||||
/**
|
||||
* Reads the current value of a fiber ref
|
||||
*/
|
||||
getFiberRef<X>(fiberRef: FiberRef<X>): X;
|
||||
/**
|
||||
* The identity of the fiber.
|
||||
*/
|
||||
id(): FiberId.Runtime;
|
||||
/**
|
||||
* The status of the fiber.
|
||||
*/
|
||||
readonly status: Effect.Effect<FiberStatus.FiberStatus>;
|
||||
/**
|
||||
* Returns the current `RuntimeFlags` the fiber is running with.
|
||||
*/
|
||||
readonly runtimeFlags: Effect.Effect<RuntimeFlags.RuntimeFlags>;
|
||||
/**
|
||||
* Adds an observer to the list of observers.
|
||||
*/
|
||||
addObserver(observer: (exit: Exit.Exit<A, E>) => void): void;
|
||||
/**
|
||||
* Removes the specified observer from the list of observers that will be
|
||||
* notified when the fiber exits.
|
||||
*/
|
||||
removeObserver(observer: (exit: Exit.Exit<A, E>) => void): void;
|
||||
/**
|
||||
* Retrieves all fiber refs of the fiber.
|
||||
*/
|
||||
getFiberRefs(): FiberRefs.FiberRefs;
|
||||
/**
|
||||
* Unsafely observes the fiber, but returns immediately if it is not
|
||||
* already done.
|
||||
*/
|
||||
unsafePoll(): Exit.Exit<A, E> | null;
|
||||
/**
|
||||
* In the background, interrupts the fiber as if interrupted from the
|
||||
* specified fiber. If the fiber has already exited, the returned effect will
|
||||
* resume immediately. Otherwise, the effect will resume when the fiber exits.
|
||||
*/
|
||||
unsafeInterruptAsFork(fiberId: FiberId.FiberId): void;
|
||||
/**
|
||||
* Gets the current context
|
||||
*/
|
||||
get currentContext(): Context<never>;
|
||||
/**
|
||||
* Gets the current context
|
||||
*/
|
||||
get currentDefaultServices(): Context<DefaultServices>;
|
||||
/**
|
||||
* Gets the current scheduler
|
||||
*/
|
||||
get currentScheduler(): Scheduler;
|
||||
/**
|
||||
* Gets the current tracer
|
||||
*/
|
||||
get currentTracer(): Tracer;
|
||||
/**
|
||||
* Gets the current span
|
||||
*/
|
||||
get currentSpan(): AnySpan | undefined;
|
||||
/**
|
||||
* Gets the current supervisor
|
||||
*/
|
||||
get currentSupervisor(): Supervisor<unknown>;
|
||||
readonly [Unify.typeSymbol]?: unknown;
|
||||
readonly [Unify.unifySymbol]?: RuntimeFiberUnify<this>;
|
||||
readonly [Unify.ignoreSymbol]?: RuntimeFiberUnifyIgnore;
|
||||
}
|
||||
/**
|
||||
* @category models
|
||||
* @since 3.8.0
|
||||
*/
|
||||
export interface RuntimeFiberUnify<A extends {
|
||||
[Unify.typeSymbol]?: any;
|
||||
}> extends FiberUnify<A> {
|
||||
RuntimeFiber?: () => A[Unify.typeSymbol] extends RuntimeFiber<infer A0, infer E0> | infer _ ? RuntimeFiber<A0, E0> : never;
|
||||
}
|
||||
/**
|
||||
* @category models
|
||||
* @since 3.8.0
|
||||
*/
|
||||
export interface RuntimeFiberUnifyIgnore extends FiberUnifyIgnore {
|
||||
Fiber?: true;
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare namespace Fiber {
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
type Runtime<A, E = never> = RuntimeFiber<A, E>;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
interface Variance<out A, out E> {
|
||||
readonly [FiberTypeId]: {
|
||||
readonly _A: Types.Covariant<A>;
|
||||
readonly _E: Types.Covariant<E>;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
interface RuntimeVariance<out A, out E> {
|
||||
readonly [RuntimeFiberTypeId]: {
|
||||
readonly _A: Types.Covariant<A>;
|
||||
readonly _E: Types.Covariant<E>;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
interface Dump {
|
||||
/**
|
||||
* The fiber's unique identifier.
|
||||
*/
|
||||
readonly id: FiberId.Runtime;
|
||||
/**
|
||||
* The status of the fiber.
|
||||
*/
|
||||
readonly status: FiberStatus.FiberStatus;
|
||||
}
|
||||
/**
|
||||
* A record containing information about a `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category models
|
||||
*/
|
||||
interface Descriptor {
|
||||
/**
|
||||
* The fiber's unique identifier.
|
||||
*/
|
||||
readonly id: FiberId.FiberId;
|
||||
/**
|
||||
* The status of the fiber.
|
||||
*/
|
||||
readonly status: FiberStatus.FiberStatus;
|
||||
/**
|
||||
* The set of fibers attempting to interrupt the fiber or its ancestors.
|
||||
*/
|
||||
readonly interruptors: HashSet.HashSet<FiberId.FiberId>;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category instances
|
||||
*/
|
||||
export declare const Order: order.Order<RuntimeFiber<unknown, unknown>>;
|
||||
/**
|
||||
* Returns `true` if the specified value is a `Fiber`, `false` otherwise.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category refinements
|
||||
*/
|
||||
export declare const isFiber: (u: unknown) => u is Fiber<unknown, unknown>;
|
||||
/**
|
||||
* Returns `true` if the specified `Fiber` is a `RuntimeFiber`, `false`
|
||||
* otherwise.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category refinements
|
||||
*/
|
||||
export declare const isRuntimeFiber: <A, E>(self: Fiber<A, E>) => self is RuntimeFiber<A, E>;
|
||||
/**
|
||||
* The identity of the fiber.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category getters
|
||||
*/
|
||||
export declare const id: <A, E>(self: Fiber<A, E>) => FiberId.FiberId;
|
||||
declare const _await: <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>>;
|
||||
export {
|
||||
/**
|
||||
* Awaits the fiber, which suspends the awaiting fiber until the result of the
|
||||
* fiber has been determined.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category getters
|
||||
*/
|
||||
_await as await };
|
||||
/**
|
||||
* Awaits on all fibers to be completed, successfully or not.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const awaitAll: <const T extends Iterable<Fiber<any, any>>>(fibers: T) => Effect.Effect<[
|
||||
T
|
||||
] extends [ReadonlyArray<infer U>] ? number extends T["length"] ? Array<U extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never> : {
|
||||
-readonly [K in keyof T]: T[K] extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never;
|
||||
} : Array<T extends Iterable<infer U> ? U extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never : never>>;
|
||||
/**
|
||||
* Retrieves the immediate children of the fiber.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category getters
|
||||
*/
|
||||
export declare const children: <A, E>(self: Fiber<A, E>) => Effect.Effect<Array<RuntimeFiber<any, any>>>;
|
||||
/**
|
||||
* Collects all fibers into a single fiber producing an in-order list of the
|
||||
* results.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const all: <A, E>(fibers: Iterable<Fiber<A, E>>) => Fiber<ReadonlyArray<A>, E>;
|
||||
/**
|
||||
* A fiber that is done with the specified `Exit` value.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const done: <A, E>(exit: Exit.Exit<A, E>) => Fiber<A, E>;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const dump: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<Fiber.Dump>;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const dumpAll: (fibers: Iterable<RuntimeFiber<unknown, unknown>>) => Effect.Effect<Array<Fiber.Dump>>;
|
||||
/**
|
||||
* A fiber that has already failed with the specified value.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const fail: <E>(error: E) => Fiber<never, E>;
|
||||
/**
|
||||
* Creates a `Fiber` that has already failed with the specified cause.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const failCause: <E>(cause: Cause.Cause<E>) => Fiber<never, E>;
|
||||
/**
|
||||
* Lifts an `Effect` into a `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category conversions
|
||||
*/
|
||||
export declare const fromEffect: <A, E>(effect: Effect.Effect<A, E>) => Effect.Effect<Fiber<A, E>>;
|
||||
/**
|
||||
* Gets the current fiber if one is running.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category utilities
|
||||
*/
|
||||
export declare const getCurrentFiber: () => Option.Option<RuntimeFiber<any, any>>;
|
||||
/**
|
||||
* Inherits values from all `FiberRef` instances into current fiber. This
|
||||
* will resume immediately.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const inheritAll: <A, E>(self: Fiber<A, E>) => Effect.Effect<void>;
|
||||
/**
|
||||
* Interrupts the fiber from whichever fiber is calling this method. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interrupt: <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>>;
|
||||
/**
|
||||
* Constructrs a `Fiber` that is already interrupted.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const interrupted: (fiberId: FiberId.FiberId) => Fiber<never>;
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interruptAs: {
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
(fiberId: FiberId.FiberId): <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>>;
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
<A, E>(self: Fiber<A, E>, fiberId: FiberId.FiberId): Effect.Effect<Exit.Exit<A, E>>;
|
||||
};
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interruptAsFork: {
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
(fiberId: FiberId.FiberId): <A, E>(self: Fiber<A, E>) => Effect.Effect<void>;
|
||||
/**
|
||||
* Interrupts the fiber as if interrupted from the specified fiber. If the
|
||||
* fiber has already exited, the returned effect will resume immediately.
|
||||
* Otherwise, the effect will resume when the fiber exits.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
<A, E>(self: Fiber<A, E>, fiberId: FiberId.FiberId): Effect.Effect<void>;
|
||||
};
|
||||
/**
|
||||
* Interrupts all fibers, awaiting their interruption.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interruptAll: (fibers: Iterable<Fiber<any, any>>) => Effect.Effect<void>;
|
||||
/**
|
||||
* Interrupts all fibers as by the specified fiber, awaiting their
|
||||
* interruption.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interruptAllAs: {
|
||||
/**
|
||||
* Interrupts all fibers as by the specified fiber, awaiting their
|
||||
* interruption.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
(fiberId: FiberId.FiberId): (fibers: Iterable<Fiber<any, any>>) => Effect.Effect<void>;
|
||||
/**
|
||||
* Interrupts all fibers as by the specified fiber, awaiting their
|
||||
* interruption.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
(fibers: Iterable<Fiber<any, any>>, fiberId: FiberId.FiberId): Effect.Effect<void>;
|
||||
};
|
||||
/**
|
||||
* Interrupts the fiber from whichever fiber is calling this method. The
|
||||
* interruption will happen in a separate daemon fiber, and the returned
|
||||
* effect will always resume immediately without waiting.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category interruption
|
||||
*/
|
||||
export declare const interruptFork: <A, E>(self: Fiber<A, E>) => Effect.Effect<void>;
|
||||
/**
|
||||
* Joins the fiber, which suspends the joining fiber until the result of the
|
||||
* fiber has been determined. Attempting to join a fiber that has erred will
|
||||
* result in a catchable error. Joining an interrupted fiber will result in an
|
||||
* "inner interruption" of this fiber, unlike interruption triggered by
|
||||
* another fiber, "inner interruption" can be caught and recovered.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const join: <A, E>(self: Fiber<A, E>) => Effect.Effect<A, E>;
|
||||
/**
|
||||
* Joins all fibers, awaiting their _successful_ completion. Attempting to
|
||||
* join a fiber that has erred will result in a catchable error, _if_ that
|
||||
* error does not result from interruption.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const joinAll: <A, E>(fibers: Iterable<Fiber<A, E>>) => Effect.Effect<Array<A>, E>;
|
||||
/**
|
||||
* Maps over the value the Fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
export declare const map: {
|
||||
/**
|
||||
* Maps over the value the Fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<A, B>(f: (a: A) => B): <E>(self: Fiber<A, E>) => Fiber<B, E>;
|
||||
/**
|
||||
* Maps over the value the Fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<A, E, B>(self: Fiber<A, E>, f: (a: A) => B): Fiber<B, E>;
|
||||
};
|
||||
/**
|
||||
* Effectually maps over the value the fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
export declare const mapEffect: {
|
||||
/**
|
||||
* Effectually maps over the value the fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>): <E>(self: Fiber<A, E>) => Fiber<A2, E2 | E>;
|
||||
/**
|
||||
* Effectually maps over the value the fiber computes.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, f: (a: A) => Effect.Effect<A2, E2>): Fiber<A2, E | E2>;
|
||||
};
|
||||
/**
|
||||
* Passes the success of this fiber to the specified callback, and continues
|
||||
* with the fiber that it returns.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
export declare const mapFiber: {
|
||||
/**
|
||||
* Passes the success of this fiber to the specified callback, and continues
|
||||
* with the fiber that it returns.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<E, E2, A, B>(f: (a: A) => Fiber<B, E2>): (self: Fiber<A, E>) => Effect.Effect<Fiber<B, E | E2>>;
|
||||
/**
|
||||
* Passes the success of this fiber to the specified callback, and continues
|
||||
* with the fiber that it returns.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category mapping
|
||||
*/
|
||||
<A, E, E2, B>(self: Fiber<A, E>, f: (a: A) => Fiber<B, E2>): Effect.Effect<Fiber<B, E | E2>>;
|
||||
};
|
||||
/**
|
||||
* Folds over the `Fiber` or `RuntimeFiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category folding
|
||||
*/
|
||||
export declare const match: {
|
||||
/**
|
||||
* Folds over the `Fiber` or `RuntimeFiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category folding
|
||||
*/
|
||||
<A, E, Z>(options: {
|
||||
readonly onFiber: (fiber: Fiber<A, E>) => Z;
|
||||
readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z;
|
||||
}): (self: Fiber<A, E>) => Z;
|
||||
/**
|
||||
* Folds over the `Fiber` or `RuntimeFiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category folding
|
||||
*/
|
||||
<A, E, Z>(self: Fiber<A, E>, options: {
|
||||
readonly onFiber: (fiber: Fiber<A, E>) => Z;
|
||||
readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z;
|
||||
}): Z;
|
||||
};
|
||||
/**
|
||||
* A fiber that never fails or succeeds.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const never: Fiber<never>;
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
export declare const orElse: {
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
<A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A2 | A, E2 | E>;
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A | A2, E | E2>;
|
||||
};
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
export declare const orElseEither: {
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
<A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<Either.Either<A2, A>, E2 | E>;
|
||||
/**
|
||||
* Returns a fiber that prefers `this` fiber, but falls back to the `that` one
|
||||
* when `this` one fails. Interrupting the returned fiber will interrupt both
|
||||
* fibers, sequentially, from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category alternatives
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<Either.Either<A2, A>, E | E2>;
|
||||
};
|
||||
/**
|
||||
* Tentatively observes the fiber, but returns immediately if it is not
|
||||
* already done.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category getters
|
||||
*/
|
||||
export declare const poll: <A, E>(self: Fiber<A, E>) => Effect.Effect<Option.Option<Exit.Exit<A, E>>>;
|
||||
/**
|
||||
* Pretty-prints a `RuntimeFiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const pretty: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<string>;
|
||||
/**
|
||||
* Returns a chunk containing all root fibers.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const roots: Effect.Effect<Array<RuntimeFiber<any, any>>>;
|
||||
/**
|
||||
* Returns a chunk containing all root fibers.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const unsafeRoots: (_: void) => Array<RuntimeFiber<any, any>>;
|
||||
/**
|
||||
* Converts this fiber into a scoped effect. The fiber is interrupted when the
|
||||
* scope is closed.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category destructors
|
||||
*/
|
||||
export declare const scoped: <A, E>(self: Fiber<A, E>) => Effect.Effect<Fiber<A, E>, never, Scope.Scope>;
|
||||
/**
|
||||
* Returns the `FiberStatus` of a `RuntimeFiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category getters
|
||||
*/
|
||||
export declare const status: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<FiberStatus.FiberStatus>;
|
||||
/**
|
||||
* Returns a fiber that has already succeeded with the specified value.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
export declare const succeed: <A>(value: A) => Fiber<A>;
|
||||
declare const void_: Fiber<void>;
|
||||
export {
|
||||
/**
|
||||
* A fiber that has already succeeded with unit.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category constructors
|
||||
*/
|
||||
void_ as void };
|
||||
/**
|
||||
* Zips this fiber and the specified fiber together, producing a tuple of
|
||||
* their output.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
export declare const zip: {
|
||||
/**
|
||||
* Zips this fiber and the specified fiber together, producing a tuple of
|
||||
* their output.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<[A, A2], E2 | E>;
|
||||
/**
|
||||
* Zips this fiber and the specified fiber together, producing a tuple of
|
||||
* their output.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<[A, A2], E | E2>;
|
||||
};
|
||||
/**
|
||||
* Same as `zip` but discards the output of that `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
export declare const zipLeft: {
|
||||
/**
|
||||
* Same as `zip` but discards the output of that `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A, E2 | E>;
|
||||
/**
|
||||
* Same as `zip` but discards the output of that `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A, E | E2>;
|
||||
};
|
||||
/**
|
||||
* Same as `zip` but discards the output of this `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
export declare const zipRight: {
|
||||
/**
|
||||
* Same as `zip` but discards the output of this `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A2, E2 | E>;
|
||||
/**
|
||||
* Same as `zip` but discards the output of this `Fiber`.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A2, E | E2>;
|
||||
};
|
||||
/**
|
||||
* Zips this fiber with the specified fiber, combining their results using the
|
||||
* specified combiner function. Both joins and interruptions are performed in
|
||||
* sequential order from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
export declare const zipWith: {
|
||||
/**
|
||||
* Zips this fiber with the specified fiber, combining their results using the
|
||||
* specified combiner function. Both joins and interruptions are performed in
|
||||
* sequential order from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<B, E2, A, C>(that: Fiber<B, E2>, f: (a: A, b: B) => C): <E>(self: Fiber<A, E>) => Fiber<C, E2 | E>;
|
||||
/**
|
||||
* Zips this fiber with the specified fiber, combining their results using the
|
||||
* specified combiner function. Both joins and interruptions are performed in
|
||||
* sequential order from left to right.
|
||||
*
|
||||
* @since 2.0.0
|
||||
* @category zipping
|
||||
*/
|
||||
<A, E, B, E2, C>(self: Fiber<A, E>, that: Fiber<B, E2>, f: (a: A, b: B) => C): Fiber<C, E | E2>;
|
||||
};
|
||||
//# sourceMappingURL=Fiber.d.ts.map
|
||||
Reference in New Issue
Block a user