import { type List, type Pair } from './list';
type NonEmptyStream<T = unknown> = Pair<T, () => Stream<T>>;
export type Stream<T = unknown> = null | NonEmptyStream<T>;
/**
 * Makes a Stream out of its arguments\
 * LOW-LEVEL FUNCTION, NOT SOURCE
 */
export declare function stream(): null;
export declare function stream<T>(...elements: T[]): NonEmptyStream<T>;
export declare function list_to_stream<T>(xs: List<T>): Stream<T>;
export declare function stream_tail<T>(stream: NonEmptyStream<T>): Stream<T>;
/**
 * Returns `true` is the given object is a stream.
 *
 * NOT Lazy: The function must evaluate all the elements of the stream
 */
export declare function is_stream(obj: unknown): obj is Stream<unknown>;
/**
 * Constructs an infinite stream of integers, beginning with n, incrementing 1 at
 * a time.
 *
 * Lazy.
 */
export declare function integers_from(n: number): Stream<number>;
/**
 * Builds a stream of n elements by applying the provided function to the
 * numbers [0, n-1].
 *
 * Lazy: f is only called when the resulting stream is forced.
 */
export declare function build_stream<T>(f: (n: number) => T, n: number): Stream<T>;
/**
 * Applies the provided function to elements of the given stream.
 *
 * Lazy: the provided function does not execute until the
 * forced by the resulting stream.
 */
export declare function stream_map<T, U>(f: (arg: T) => U, s: Stream<T>): Stream<U>;
/**
 * Returns a substream containing the elements that the provided predicate returned `true` for.
 *
 * Partially Lazy: Both the predicate and stream are evaluated as necessary
 */
export declare function stream_filter<T, U extends T>(f: (arg: T) => arg is U, s: Stream<T>): Stream<U>;
export declare function stream_filter<T>(f: (arg: T) => boolean, s: Stream<T>): Stream<T>;
/**
 * Applies the given function to every single element of the stream.
 *
 * NOT lazy: This function evaluates the entire stream.
 */
export declare function stream_for_each<T>(f: (arg: T) => void, s: Stream<T>): boolean;
/**
 * Accumulate applies given operation op to elements of a stream
 * in a right-to-left order, first apply op to the last element
 * and an initial element, resulting in r1, then to the second-last
 * element and r1, resulting in r2, etc, and finally to the first element
 * and r_n-1, where n is the length of the list. `accumulate(op,zero,list(1,2,3))`
 * results in `op(1, op(2, op(3, zero)))`.
 *
 * NOT lazy: This function evaluates the entire stream when called
 */
export declare function stream_accumulate<T, U>(f: (each: T, result: U) => U, initial: U, stream: Stream<T>): U;
/**
 * Returns the length of the stream.
 *
 * NOT lazy: The function must evaluate the entire stream
 */
export declare function stream_length(s: Stream<unknown>): number;
/**
 * Returns the nth element of the stream.
 *
 * NOT lazy: The stream must be evaluated up to the nth element.
 */
export declare function stream_ref<T>(s: Stream<T>, n: number): T;
/**
 * Appends a stream to the end of another stream.
 *
 * @param lhs Stream to append to
 * @param rhs Stream to be appending
 *
 * Lazy: `rhs` is only evaluated after `lhs` is fully evaluated. This
 * does mean that if `lhs` is infinite elements from `rhs` will never be evaluated.
 */
export declare function stream_append<T>(lhs: Stream<T>, rhs: Stream<T>): Stream<T>;
/**
 * Converts the given stream to a {@link List|list}.
 *
 * NOT Lazy: Function has to evaluate every element of the stream
 * to populate the resulting list
 */
export declare function stream_to_list<T>(stream: Stream<T>): List<T>;
export {};