import { Equals } from "@tsplus/stdlib/structure/Equals";
import { Hash } from "@tsplus/stdlib/structure/Hash";
import { HKT } from "@tsplus/stdlib/prelude/HKT";
import type { Lazy } from "@tsplus/stdlib/data/Function";
/**
 * `Eval<A>` is a purely functional description of a computation.
 *
 * Note: while for general cases the `Sync` data type is preferrable,
 * this data type is designed for speed and low allocations,
 * it is internally used to suspend recursive procedures but can be
 * useful whenever you need a fast sync computation that cannot fail
 * and that doesn't require any environment.
 *
 * @tsplus type Eval
 */
export interface Eval<A> {
    readonly _A: () => A;
    readonly _TypeId: unique symbol;
}
export type EvalInternal<A> = Succeed<A> | FlatMap<any, A> | Suspend<A>;
export declare const EvalSym: unique symbol;
export type EvalSym = typeof EvalSym;
export declare const _A: unique symbol;
export type _A = typeof _A;
/**
 * @tsplus type Eval.Ops
 */
export interface EvalOps {
    $: EvalAspects;
}
export declare const Eval: EvalOps;
/**
 * @tsplus type Eval.Aspects
 */
export interface EvalAspects {
}
/**
 * @tsplus unify Eval
 */
export declare function unifyEval<X extends Eval<any>>(self: X): Eval<[X] extends [Eval<infer AX>] ? AX : never>;
export interface Succeed<A> extends Eval<A> {
}
export declare class Succeed<A> implements Equals {
    readonly a: Lazy<A>;
    readonly _tag = "Succeed";
    readonly [EvalSym]: EvalSym;
    readonly [_A]: () => A;
    constructor(a: Lazy<A>);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
}
export interface Suspend<A> extends Eval<A> {
}
export declare class Suspend<A> implements Equals {
    readonly f: Lazy<EvalInternal<A>>;
    readonly _tag = "Suspend";
    readonly [EvalSym]: EvalSym;
    readonly [_A]: () => A;
    constructor(f: Lazy<EvalInternal<A>>);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
}
export interface FlatMap<A, B> extends Eval<B> {
}
export declare class FlatMap<A, B> implements Equals {
    readonly value: EvalInternal<A>;
    readonly cont: (a: A) => EvalInternal<B>;
    readonly _tag = "FlatMap";
    readonly [EvalSym]: EvalSym;
    readonly [_A]: () => A;
    constructor(value: EvalInternal<A>, cont: (a: A) => EvalInternal<B>);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
}
export interface EvalF extends HKT {
    readonly type: Eval<this["A"]>;
}
export declare namespace Eval {
    type HKT = EvalF;
}
//# sourceMappingURL=definition.d.ts.map