@fncts/io 0.0.1

package/FiberRef/api.d.ts

@@ -0,0 +1,89 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus fluent fncts.io.FiberRef modify
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function modify_<A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
+/**
+ * @tsplus fluent fncts.io.FiberRef update
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<void>;
+/**
+ * @tsplus fluent fncts.io.FiberRef set
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function set_<A>(fiberRef: FiberRef<A>, a: A): UIO<void>;
+/**
+ * @tsplus getter fncts.io.FiberRef get
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function get<A>(fiberRef: FiberRef<A>): UIO<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndSet
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function getAndSet_<A>(fiberRef: FiberRef<A>, a: A): UIO<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndUpdate
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A): UIO<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>): UIO<A>;
+/**
+ * Returns an `IO` that runs with `value` bound to the current fiber.
+ *
+ * Guarantees that fiber data is properly restored via `bracket`.
+ * @tsplus fluent fncts.io.FiberRef locally
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function locally_<A>(fiberRef: FiberRef<A>, value: A): <R1, E1, B>(use: import("@fncts/io/IO/definition").IO<R1, E1, B>) => import("@fncts/io/IO/definition").IO<R1, E1, B>;
+/**
+ * Returns an `IO` that runs with `f` applied to the current fiber.
+ *
+ * Guarantees that fiber data is properly restored via `bracket`.
+ * @tsplus fluent fncts.io.FiberRef locallyWith
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A): <R1, E1, B>(use: import("@fncts/io/IO/definition").IO<R1, E1, B>) => import("@fncts/io/IO/definition").IO<R1, E1, B>;
+/**
+ * @tsplus fluent fncts.io.FiberRef getWith
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function getWith_<A, R, E, B>(fiberRef: FiberRef<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, B>;
+/**
+ * @tsplus getter fncts.io.FiberRef remove
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function remove<A>(self: FiberRef<A>, __tsplusTrace?: string): UIO<void>;
+/**
+ * @tsplus getter fncts.io.FiberRef diff
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function diff<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): (oldValue: Value, newValue: Value) => Patch;
+/**
+ * @tsplus getter fncts.io.FiberRef initial
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function initial<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Value;
+/**
+ * @tsplus getter fncts.io.FiberRef combine
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function combine<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): (first: Patch, second: Patch) => Patch;
+/**
+ * @tsplus getter fncts.io.FiberRef patch
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function patch<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): (patch: Patch) => (oldValue: Value) => Value;
+/**
+ * @tsplus getter fncts.io.FiberRef fork
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patch;

package/FiberRef/constructors.d.ts

@@ -0,0 +1,63 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { FiberScope } from "@fncts/io/FiberScope/definition";
+import { LogLevel } from "@fncts/io/LogLevel";
+import { List } from "@fncts/base/collection/immutable/List";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import type { LogSpan } from "@fncts/io/LogSpan";
+import { Patch } from "@fncts/base/data/Patch";
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare 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>;
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare function unsafeMakeEnvironment<A>(initial: Environment<A>): FiberRef.WithPatch<Environment<A>, Patch<A, A>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps unsafeMake
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare function unsafeMake<A>(initial: A, fork?: (a: A) => A, join?: (a0: A, a1: A) => A): FiberRef.WithPatch<A, (_: A) => A>;
+/**
+ * @tsplus static fncts.io.FiberRefOps make
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare function make<A>(initial: A, fork?: (a: A) => A, join?: (a: A, a1: A) => A): IO<Has<Scope>, never, FiberRef<A>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps forkScopeOverride
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const forkScopeOverride: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("@fncts/base/data/Maybe").Maybe<import("../FiberScope").FiberScope>, (_: import("@fncts/base/data/Maybe").Maybe<import("../FiberScope").FiberScope>) => import("@fncts/base/data/Maybe").Maybe<import("../FiberScope").FiberScope>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentEnvironment
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const currentEnvironment: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("@fncts/base/data/Environment").Environment<unknown>, Patch<unknown, unknown>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps fiberName
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const fiberName: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("@fncts/base/data/Maybe").Maybe<string>, (_: import("@fncts/base/data/Maybe").Maybe<string>) => import("@fncts/base/data/Maybe").Maybe<string>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogLevel
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const currentLogLevel: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("../LogLevel").LogLevel, (_: import("../LogLevel").LogLevel) => import("../LogLevel").LogLevel>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogSpan
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const currentLogSpan: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("@fncts/base/collection/immutable/List").List<LogSpan>, (_: import("@fncts/base/collection/immutable/List").List<LogSpan>) => import("@fncts/base/collection/immutable/List").List<LogSpan>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
+ * @tsplus location "@fncts/io/FiberRef/constructors"
+ */
+export declare const currentLogAnnotations: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<import("@fncts/base/collection/immutable/HashMap").HashMap<string, string>, (_: import("@fncts/base/collection/immutable/HashMap").HashMap<string, string>) => import("@fncts/base/collection/immutable/HashMap").HashMap<string, string>>;

package/FiberRef/definition.d.ts

@@ -0,0 +1,41 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+export declare const FiberRefTypeId: unique symbol;
+export declare type FiberRefTypeId = typeof FiberRefTypeId;
+/**
+ * @tsplus type fncts.io.FiberRef
+ * @tsplus companion fncts.io.FiberRefOps
+ */
+export declare abstract class FiberRef<Value> {
+    readonly _typeId: FiberRefTypeId;
+    readonly _A: () => Value;
+    readonly _Patch: unknown;
+}
+export declare namespace FiberRef {
+    interface WithPatch<Value, Patch> extends FiberRef<Value> {
+        readonly _Patch: Patch;
+    }
+}
+/**
+ * @tsplus type fncts.io.FiberRef
+ */
+export declare class FiberRefInternal<Value, Patch> extends FiberRef<Value> implements Hashable, Equatable {
+    readonly _initial: Value;
+    readonly _diff: (oldValue: Value, newValue: Value) => Patch;
+    readonly _combine: (first: Patch, second: Patch) => Patch;
+    readonly _patch: (patch: Patch) => (oldValue: Value) => Value;
+    readonly _fork: Patch;
+    readonly _Patch: Patch;
+    private readonly id;
+    constructor(_initial: Value, _diff: (oldValue: Value, newValue: Value) => Patch, _combine: (first: Patch, second: Patch) => Patch, _patch: (patch: Patch) => (oldValue: Value) => Value, _fork: Patch);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+export declare function isFiberRef(u: unknown): u is FiberRef<unknown>;
+declare type Concrete<Value, Patch> = FiberRefInternal<Value, Patch>;
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<A, P>(_: FiberRef.WithPatch<A, P>): asserts _ is Concrete<A, P>;
+export declare function concrete<A>(_: FiberRef<A>): asserts _ is Concrete<A, unknown>;
+export {};

package/FiberRef.d.ts

@@ -0,0 +1,5 @@
+export * from "./FiberRef/api.js";
+export * from "./FiberRef/constructors.js";
+export * from "./FiberRef/definition.js";
+export * from "./FiberRef/api/locallyScoped.js";
+export * from "./FiberRef/api/locallyScopedWith.js";

package/FiberRefs/api.d.ts

@@ -0,0 +1,15 @@
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { Cons } from "@fncts/base/collection/immutable/List";
+import { FiberRefs } from "@fncts/io/FiberRefs/definition";
+/**
+ * @tsplus getter fncts.io.FiberRefs fiberRefs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
+/**
+ * @tsplus static fncts.io.FiberRefsOps __call
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs;

package/FiberRefs/definition.d.ts

@@ -0,0 +1,14 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Cons } from "@fncts/base/collection/immutable/List";
+export declare const FiberRefsTypeId: unique symbol;
+export declare type FiberRefsTypeId = typeof FiberRefsTypeId;
+/**
+ * @tsplus type fncts.io.FiberRefs
+ * @tsplus companion fncts.io.FiberRefsOps
+ */
+export declare class FiberRefs {
+    readonly fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
+    readonly _typeId: FiberRefsTypeId;
+    constructor(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>);
+}

package/FiberRefs/join.d.ts

@@ -0,0 +1,8 @@
+import { FiberRefs } from "@fncts/io/FiberRefs";
+import { Cons, List } from "@fncts/base/collection/immutable/List";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus fluent fncts.io.FiberRefs join
+ * @tsplus location "@fncts/io/FiberRefs/join"
+ */
+export declare function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs): FiberRefs;

package/FiberRefs.d.ts

@@ -0,0 +1,3 @@
+export * from "./FiberRefs/api.js";
+export * from "./FiberRefs/definition.js";
+export * from "./FiberRefs/join.js";

package/FiberScope/constructors.d.ts

@@ -0,0 +1,16 @@
+import { FiberScope } from "@fncts/io/FiberScope/definition";
+import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import { Global } from "@fncts/io/FiberScope/definition";
+/**
+ * The global scope. Anything forked onto the global scope is not supervised,
+ * and will only terminate on its own accord (never from interruption of a
+ * parent fiber, because there is no parent fiber).
+ * @tsplus static fncts.io.FiberScopeOps global
+ * @tsplus location "@fncts/io/FiberScope/constructors"
+ */
+export declare const global: Global;
+/**
+ * @tsplus static fncts.io.FiberScopeOps unsafeMake
+ * @tsplus location "@fncts/io/FiberScope/constructors"
+ */
+export declare function unsafeMake(fiber: FiberContext<any, any>): FiberScope;

package/FiberScope/definition.d.ts

@@ -0,0 +1,24 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+/**
+ * A `Scope` represents the scope of a fiber lifetime. The scope of a fiber can
+ * be retrieved using IO.descriptor, and when forking fibers, you can
+ * specify a custom scope to fork them on by using the IO#forkIn.
+ *
+ * @tsplus type fncts.io.FiberScope
+ * @tsplus companion fncts.io.FiberScopeOps
+ */
+export declare abstract class FiberScope {
+    abstract fiberId: FiberId;
+    abstract unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+}
+export declare class Global extends FiberScope {
+    get fiberId(): FiberId;
+    unsafeAdd(_child: FiberContext<any, any>): boolean;
+}
+export declare class Local extends FiberScope {
+    readonly fiberId: FiberId;
+    private parentRef;
+    constructor(fiberId: FiberId, parentRef: WeakRef<FiberContext<unknown, unknown>>);
+    unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+}

package/FiberScope.d.ts

@@ -0,0 +1,2 @@
+export * from "./FiberScope/constructors.js";
+export * from "./FiberScope/definition.js";

package/FiberState/api.d.ts

@@ -0,0 +1,7 @@
+import { Cause } from "@fncts/base/data/Cause";
+import type { FiberState } from "./definition.js";
+/**
+ * @tsplus getter fncts.FiberState interruptorsCause
+ * @tsplus location "@fncts/io/FiberState/api"
+ */
+export declare function interruptorsCause<E, A>(state: FiberState<E, A>): Cause<never>;

package/FiberState/constructors.d.ts

@@ -0,0 +1,22 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { Cause } from "@fncts/base/data/Cause";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { UIO } from "@fncts/io/IO/definition";
+import type { Callback, FiberState } from "./definition.js";
+import { CancellerState } from "../CancellerState.js";
+import { FiberStatus } from "../FiberStatus.js";
+/**
+ * @tsplus static fncts.FiberStateOps initial
+ * @tsplus location "@fncts/io/FiberState/constructors"
+ */
+export declare function initial<E, A>(): FiberState<E, A>;
+/**
+ * @tsplus static fncts.FiberStateOps done
+ * @tsplus location "@fncts/io/FiberState/constructors"
+ */
+export declare function done<E, A>(value: Exit<E, A>): FiberState<E, A>;
+/**
+ * @tsplus static fncts.FiberStateOps executing
+ * @tsplus location "@fncts/io/FiberState/constructors"
+ */
+export declare function executing<E, A>(status: FiberStatus, observers: Set<Callback<never, Exit<E, A>>>, suppressed: Cause<never>, interruptors: Set<FiberId>, asyncCanceller: CancellerState, mailbox: UIO<any> | null): FiberState<E, A>;

package/FiberState/definition.d.ts

@@ -0,0 +1,38 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { Cause } from "@fncts/base/data/Cause";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { UIO } from "@fncts/io/IO/definition";
+import type { CancellerState } from "../CancellerState.js";
+import { FiberStatus } from "../FiberStatus.js";
+/**
+ * @tsplus type fncts.FiberState
+ */
+export declare type FiberState<E, A> = Executing<E, A> | Done<E, A>;
+/**
+ * @tsplus type fncts.FiberStateOps
+ */
+export interface FiberStateOps {
+}
+export declare const FiberState: FiberStateOps;
+export declare namespace FiberState {
+    type Callback<E, A> = (exit: Exit<E, A>) => void;
+}
+export declare type Callback<E, A> = (exit: Exit<E, A>) => void;
+export declare class Executing<E, A> {
+    status: FiberStatus;
+    observers: Set<Callback<never, Exit<E, A>>>;
+    suppressed: Cause<never>;
+    interruptors: Set<FiberId>;
+    asyncCanceller: CancellerState;
+    mailbox: UIO<any> | null;
+    readonly _tag = "Executing";
+    constructor(status: FiberStatus, observers: Set<Callback<never, Exit<E, A>>>, suppressed: Cause<never>, interruptors: Set<FiberId>, asyncCanceller: CancellerState, mailbox: UIO<any> | null);
+}
+export declare class Done<E, A> {
+    readonly value: Exit<E, A>;
+    readonly _tag = "Done";
+    readonly interrupted: import("@fncts/base/data/Cause.js").Cause<never>;
+    readonly status: FiberStatus;
+    readonly interruptors: Set<FiberId>;
+    constructor(value: Exit<E, A>);
+}

package/FiberState.d.ts

@@ -0,0 +1,3 @@
+export * from "./FiberState/api.js";
+export * from "./FiberState/constructors.js";
+export * from "./FiberState/definition.js";

package/FiberStatus/constructors.d.ts

@@ -0,0 +1,22 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberStatus } from "./definition.js";
+/**
+ * @tsplus static fncts.FiberStatusOps done
+ * @tsplus location "@fncts/io/FiberStatus/constructors"
+ */
+export declare const done: FiberStatus;
+/**
+ * @tsplus static fncts.FiberStatusOps finishing
+ * @tsplus location "@fncts/io/FiberStatus/constructors"
+ */
+export declare function finishing(interrupting: boolean): FiberStatus;
+/**
+ * @tsplus static fncts.FiberStatusOps running
+ * @tsplus location "@fncts/io/FiberStatus/constructors"
+ */
+export declare function running(interrupting: boolean): FiberStatus;
+/**
+ * @tsplus static fncts.FiberStatusOps suspended
+ * @tsplus location "@fncts/io/FiberStatus/constructors"
+ */
+export declare function suspended(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string): FiberStatus;

package/FiberStatus/definition.d.ts

@@ -0,0 +1,59 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+export declare const enum FiberStatusTag {
+    Done = "Done",
+    Finishing = "Finishing",
+    Running = "Running",
+    Suspended = "Suspended"
+}
+/**
+ * @tsplus companion fncts.FiberStatus.DoneOps
+ */
+export declare class Done {
+    readonly _tag = FiberStatusTag.Done;
+    get isInterrupting(): boolean;
+    withInterrupting(): FiberStatus;
+}
+/**
+ * @tsplus companion fncts.FiberStatus.FinishingOps
+ */
+export declare class Finishing {
+    readonly interrupting: boolean;
+    readonly _tag = FiberStatusTag.Finishing;
+    constructor(interrupting: boolean);
+    get isInterrupting(): boolean;
+    withInterrupting(newInterrupting: boolean): FiberStatus;
+}
+/**
+ * @tsplus companion fncts.FiberStatus.RunningOps
+ */
+export declare class Running {
+    readonly interrupting: boolean;
+    readonly _tag = FiberStatusTag.Running;
+    constructor(interrupting: boolean);
+    get isInterrupting(): boolean;
+    withInterrupting(newInterrupting: boolean): FiberStatus;
+}
+/**
+ * @tsplus companion fncts.FiberStatus.SuspendedOps
+ */
+export declare class Suspended {
+    readonly interrupting: boolean;
+    readonly interruptible: boolean;
+    readonly epoch: number;
+    readonly blockingOn: FiberId;
+    readonly asyncTrace?: string | undefined;
+    readonly _tag = FiberStatusTag.Suspended;
+    constructor(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string | undefined);
+    get isInterrupting(): boolean;
+    withInterrupting(newInterrupting: boolean): Suspended;
+}
+/**
+ * @tsplus type fncts.FiberStatus
+ */
+export declare type FiberStatus = Done | Finishing | Running | Suspended;
+/**
+ * @tsplus type fncts.FiberStatusOps
+ */
+export interface FiberStatusOps {
+}
+export declare const FiberStatus: FiberStatusOps;

package/FiberStatus.d.ts

@@ -0,0 +1,2 @@
+export * from "./FiberStatus/constructors.js";
+export * from "./FiberStatus/definition.js";

package/Future/api.d.ts

@@ -0,0 +1,113 @@
+import { Future } from "@fncts/io/Future";
+import { Exit } from "@fncts/base/data/Exit";
+import { UIO, IO, FIO } from "@fncts/io/IO/definition";
+import { Cause } from "@fncts/base/data/Cause";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * Exits the future with the specified exit, which will be propagated to all
+ * fibers waiting on the value of the future.
+ * @tsplus fluent fncts.io.Future done
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>): UIO<boolean>;
+/**
+ * Fails the future with the specified error, which will be propagated to all
+ * fibers waiting on the value of the future.
+ * @tsplus fluent fncts.io.Future fail
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function fail_<E, A>(future: Future<E, A>, e: E): UIO<boolean>;
+/**
+ * Halts the future with the specified cause, which will be propagated to all
+ * fibers waiting on the value of the future.
+ * @tsplus fluent fncts.io.Future failCause
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>): UIO<boolean>;
+/**
+ * Completes the future with the result of the specified effect. If the
+ * future has already been completed, the method will produce false.
+ *
+ * Note that `Future.completeWith` will be much faster, so consider using
+ * that if you do not need to memoize the result of the specified effect.
+ * @tsplus fluent fncts.io.Future fulfill
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>): IO<R, never, boolean>;
+/**
+ * Completes the future with the specified effect. If the future has
+ * already been completed, the method will produce false.
+ *
+ * Note that since the future is completed with an IO, the effect will
+ * be evaluated each time the value of the future is retrieved through
+ * combinators such as `wait`, potentially producing different results if
+ * the effect produces different results on subsequent evaluations. In this
+ * case te meaning of the "exactly once" guarantee of `Future` is that the
+ * future can be completed with exactly one effect. For a version that
+ * completes the future with the result of an IO see
+ * `Future.complete`.
+ * @tsplus fluent fncts.io.Future fulfillWith
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>): UIO<boolean>;
+/**
+ * Kills the future with the specified error, which will be propagated to all
+ * fibers waiting on the value of the future.
+ * @tsplus fluent fncts.io.Future halt
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function halt_<E, A>(future: Future<E, A>, defect: unknown): UIO<boolean>;
+/**
+ * Completes the future with interruption. This will interrupt all fibers
+ * waiting on the value of the future as by the fiber calling this method.
+ * @tsplus getter fncts.io.Future interrupt
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function interrupt<E, A>(future: Future<E, A>): UIO<boolean>;
+/**
+ * Completes the future with interruption. This will interrupt all fibers
+ * waiting on the value of the future as by the specified fiber.
+ * @tsplus fluent fncts.io.Future interruptAs
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function interruptAs_<E, A>(future: Future<E, A>, id: FiberId): UIO<boolean>;
+/**
+ * Checks for completion of this Future. Produces true if this future has
+ * already been completed with a value or an error and false otherwise.
+ * @tsplus getter fncts.io.Future isDone
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function isDone<E, A>(future: Future<E, A>): UIO<boolean>;
+/**
+ * Checks for completion of this Future. Returns the result effect if this
+ * future has already been completed or a `None` otherwise.
+ * @tsplus getter fncts.io.Future poll
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function poll<E, A>(future: Future<E, A>): UIO<Maybe<FIO<E, A>>>;
+/**
+ * Completes the future with the specified value.
+ * @tsplus fluent fncts.io.Future succeed
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function succeed_<A, E>(future: Future<E, A>, a: A): import("@fncts/io/IO").UIO<boolean>;
+/**
+ * Retrieves the value of the future, suspending the fiber running the action
+ * until the result is available.
+ * @tsplus fluent fncts.io.Future unsafeDone
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>): void;
+/**
+ * @tsplus fluent fncts.io.Future unsafeSucceed
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function unsafeSucceed_<A>(future: Future<never, A>, a: A): void;
+/**
+ * Retrieves the value of the future, suspending the fiber running the action
+ * until the result is available.
+ * @tsplus getter fncts.io.Future await
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function wait<E, A>(future: Future<E, A>): IO<unknown, E, A>;

package/Future/constructors.d.ts

@@ -0,0 +1,21 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+import { FiberId } from "@fncts/base/data/FiberId";
+/**
+ * Makes a new future to be completed by the fiber creating the future.
+ * @tsplus static fncts.io.FutureOps make
+ * @tsplus location "@fncts/io/Future/constructors"
+ */
+export declare function make<E, A>(): IO<unknown, never, Future<E, A>>;
+/**
+ * Makes a new future to be completed by the fiber with the specified id.
+ * @tsplus static fncts.io.FutureOps makeAs
+ * @tsplus location "@fncts/io/Future/constructors"
+ */
+export declare function makeAs<E, A>(fiberId: FiberId): import("../IO").UIO<import("@fncts/io/Future/definition").Future<E, A>>;
+/**
+ * Makes a new future to be completed by the fiber with the specified id.
+ * @tsplus static fncts.io.FutureOps unsafeMake
+ * @tsplus location "@fncts/io/Future/constructors"
+ */
+export declare function unsafeMake<E, A>(fiberId: FiberId): import("@fncts/io/Future/definition").Future<E, A>;

package/Future/definition.d.ts

@@ -0,0 +1,27 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import { List } from "@fncts/base/collection/immutable/List";
+import { FIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus type fncts.io.Future
+ * @tsplus companion fncts.io.FutureOps
+ */
+export declare class Future<E, A> {
+    state: State<E, A>;
+    readonly blockingOn: FiberId;
+    constructor(state: State<E, A>, blockingOn: FiberId);
+}
+export declare const enum FutureStateTag {
+    Done = "Done",
+    Pending = "Pending"
+}
+export declare class Pending<E, A> {
+    readonly joiners: List<(_: FIO<E, A>) => void>;
+    readonly _tag = FutureStateTag.Pending;
+    constructor(joiners: List<(_: FIO<E, A>) => void>);
+}
+export declare class Done<E, A> {
+    readonly value: FIO<E, A>;
+    readonly _tag = FutureStateTag.Done;
+    constructor(value: FIO<E, A>);
+}
+export declare type State<E, A> = Done<E, A> | Pending<E, A>;

package/Future.d.ts

@@ -0,0 +1,3 @@
+export * from "./Future/api.js";
+export * from "./Future/constructors.js";
+export * from "./Future/definition.js";