import { Either } from './Either';
import { Lazy } from './function';
import { Alternative1 } from './Functors/Alternative';
import { ChainRec1 } from './Functors/ChainRec';
import { Monad1 } from './Functors/Monad';
import { Maybe } from './Maybe';
import { Predicate } from './Predicate';
export declare const IterKind: unique symbol;
export declare type IterKind = typeof IterKind;
declare module './Functors/HKT' {
    interface Kinded<T> {
        readonly [IterKind]: Iterable<T[0]>;
    }
}
/**
 * Returns whether an iterator is empty.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(isEmpty([]), true)
 * assert.deepStrictEqual(isEmpty(new Map()), true)
 * assert.deepStrictEqual(isEmpty(new Set()), true)
 * assert.deepStrictEqual(isEmpty({ [Symbol.iterator]: function*() {} }), true)
 * ```
 */
export declare const isEmpty: <A>(ma: Iterable<A>) => boolean;
/**
 * Returns if the iterator is instanceof `Array`, otherwise returns a new array created by `Array.from`.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(toArray([1, 2, 3]), [1, 2, 3])
 * assert.deepStrictEqual(toArray(new Set([1, 2, 3])), [1, 2, 3])
 * ```
 */
export declare const toArray: <A>(ma: Iterable<A>) => A[];
/**
 * Returns an iterator with the elements at last.
 */
export declare function push<A>(a: Iterable<A>, ...as: A[]): Iterable<A>;
/**
 * Returns an iterator with the elements at start.
 */
export declare function unshift<T>(a: Iterable<T>, ...items: T[]): Iterable<T>;
/**
 * Creates an iterator with an array.
 */
export declare function of<A>(...as: A[]): Iterable<A>;
/**
 * Returns whether the index is out of bounds.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe([1, 2, 3], isOutOfBounds(1)), false)
 * assert.deepStrictEqual(pipe([1, 2, 3], isOutOfBounds(-1)), true)
 * assert.deepStrictEqual(pipe([1, 2, 3], isOutOfBounds(3)), true)
 * ```
 */
export declare const isOutOfBounds: (index: number) => <A>(as: Iterable<A>) => boolean;
/**
 * Returns the value at the index of a iterator and wrapped in a Some if the index is not out of bounds. Otherwise returns a none.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe([1, 2, 3], nth(1)), some(2))
 * assert.deepStrictEqual(pipe([1, 2, 3], nth(-1)), some(3))
 * assert.deepStrictEqual(pipe([1, 2, 3], nth(3)), none)
 * ```
 */
export declare const nth: (index: number) => <A>(as: Iterable<A>) => Maybe<A>;
/**
 * Returns an empty list.
 * @returns
 */
export declare const empty: <A>() => Iterable<A>;
/**
 * Alias of `empty`.
 */
export declare const zero: <A>() => Iterable<A>;
/**
 * Calls a callback function on each element of the iterator, and returns an iterator contains the results.
 */
export declare const map: <A, B>(f: (a: A) => B) => (ma: Iterable<A>) => Iterable<B>;
/**
 * Creates an iterator from a given range with step.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(range, collect)(1, 3), [1, 2])
 * assert.deepStrictEqual(flow(range, collect)(1, 6, 2), [1, 3, 5])
 * assert.deepStrictEqual(flow(range, collect)(3, 1), [3, 2])
 * ```
 */
export declare function range(from: number, end: number, step?: number): Iterable<number>;
/**
 * Creates an iterator from a range starting from `0` to end with step.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(to, collect)(3), [1, 2])
 * assert.deepStrictEqual(flow(to, collect)(6, 2), [0, 2, 4])
 * ```
 */
export declare const to: (end: number, step?: number) => Iterable<number>;
/**
 * Creates an iterator of length `n` initialized with `f(i)`.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(makeBy, collect)(3, n => n * 2), [0, 2, 4])
 * ```
 */
export declare function makeBy<A>(n: number, f: (i: number) => A): Iterable<A>;
/**
 * Creates an iterator from a value repeated the specified number of times.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(replicate, collect)('a', 2), ['a', 'a'])
 * ```
 */
export declare const replicate: <A>(ma: A, n: number) => Iterable<A>;
/**
 * Creates an array from an iterator.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(collect([1, 2, 3]), [1, 2, 3]))
 * assert.deepStrictEqual(collect(function* () {
 *  for(let i = 1; i <=3; i++) yield i
 * }), [1, 2, 3]))
 * ```
 */
export declare const collect: <A>(ma: Iterable<A>) => A[];
/**
 * Adds all the elements of an iterator into a string, separated by the specified separator string.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe(['a', 'b', 'c'], join('-')), 'a-b-c')
 * ```
 */
export declare const join: (seperator?: string) => <A>(ma: Iterable<A>) => string;
/**
 * Returns the length or size of an iterator.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(count([1, 2, 3]), 3)
 * assert.deepStrictEqual(count(function* () {
 *   yield 1
 *   yield 2
 *   yield 3
 * }), 3)
 * ```
 */
export declare const count: <A>(ma: Iterable<A>) => number;
/**
 * Returns an iterator that elements meet the condition specified in a predicate function.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(
 *   pipe(
 *     [1, 2, 3, 4],
 *     filter(a => a % 2 === 0)
 *   ),
 *   [2, 4]
 * )
 * ```
 */
export declare const filter: <A>(predicate: Predicate<A>) => (ma: Iterable<A>) => Iterable<A>;
/**
 * Concats two iterators that have different types.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe([1], alt(() => ['2', '3']), collect), [1, '2', '3'])
 * ```
 */
export declare const alt: <B>(that: Lazy<Iterable<B>>) => <A>(ma: Iterable<A>) => Iterable<B | A>;
/**
 * Chains the result of the applying function to the iterator with the other.
 *
 * @example
 *
 * ```ts
 * const f = (s: string) => (n: number) => s + n
 * assert.deepStrictEqual(pipe(['a', 'b'], map(f), ap([1, 2]), collect), ['a1', 'a2', 'b1', 'b2'])
 * ```
 */
export declare const ap: <A>(ma: Iterable<A>) => <B>(f: Iterable<(a: A) => B>) => Iterable<B>;
/**
 * Calls the specified callback function for all the elements in an iterator.
 * The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(
 *   pipe([2, 3, 4], reduce((acc: number, cur: number) => acc + cur, 1)), 10
 * )
 * ```
 */
export declare function reduce<A>(f: (b: A, a: A, i: number, as: Iterable<A>) => A): (as: Iterable<A>) => A;
export declare function reduce<A>(f: (b: A, a: A, i: number, as: Iterable<A>) => A, b: A): (as: Iterable<A>) => A;
export declare function reduce<A, B>(f: (b: B, a: A, i: number, as: Iterable<A>) => B, b: B): (as: Iterable<A>) => B;
/**
 * Returns `Some` the first element of an iterator if it exists, otherwise returns `None`.
 *
 * @example
 *
 * assert.deepStrictEqual(head([1, 2, 3]), some(1))
 * assert.deepStrictEqual(head([]), none)
 */
export declare const head: <A>(ma: Iterable<A>) => import("./Maybe").None | import("./Maybe").Some<A>;
/**
 * Try to return the first element of an iterator.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(tryHead([1, 2, 3]), 1)
 * assert.deepStrictEqual(tryHead([]), undefined)
 * ```
 */
export declare const tryHead: <A>(ma: Iterable<A>) => A | undefined;
/**
 * Returns `Some` the last element of an iterator if it exists, otherwise returns `None`.
 *
 * @example
 *
 * assert.deepStrictEqual(tail([1, 2, 3]), some(3))
 * assert.deepStrictEqual(tail([]), none)
 */
export declare const tail: <A>(ma: Iterable<A>) => Maybe<A>;
/**
 * Try to return the last element of an iterator.
 *
 * @example
 *
 * assert.deepStrictEqual(tryTail([1, 2, 3]), 3)
 * assert.deepStrictEqual(tryTail([]), undefined)
 */
export declare const tryTail: <A>(ma: Iterable<A>) => A | undefined;
/**
 * Combines two or more iterators.
 *
 * @example
 *
 * assert.deepStrictEqual(pipe([1], concat([2, 3], [4, 5]), collect), [1, 2, 3, 4, 5])
 */
export declare const concat: <A>(...items: Iterable<A>[]) => <B>(ma: Iterable<B>) => Iterable<A | B>;
/**
 * Takes two iterator and returns an iterator of the function results. If one iterator is short, excess items of the longer iterator are discarded.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(zipWith, collect)([1, 2], [1, 2], (a, b) => a + b), [2, 4])
 * assert.deepStrictEqual(flow(zipWith, collect)(function* () { yield 1 }, [1, 2], (a, b) => a + b), [2])
 * ```
 */
export declare function zipWith<A, B, C>(a: Iterable<A>, b: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>;
/**
 * Takes two iterator and returns an iterator of corresponding pairs. If one iterator is short, excess items of the longer iterator are discarded.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flow(zip, collect)([1, 2], [1, 2]), [[1, 1], [2, 2]])
 * assert.deepStrictEqual(flow(zip, collect)(function* () { yield 1 }, [1, 2]), [[1, 1]])
 * ```
 */
export declare function zip<A, B>(a: Iterable<A>, b: Iterable<B>): Iterable<[A, B]>;
/**
 * Similar as reverse of `zip`. Takes an iterator of pairs but returns two corresponding arrarys.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(unzip([[1, 2], [3, 4]]), [[1, 3], [2, 4]])
 * ```
 */
export declare const unzip: <A, B>(as: Iterable<[A, B]>) => [A[], B[]];
/**
 * Takes an iterator of iterators of `A` and flattens them into an iterator of `A`.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(flatten([["a"], ["b", "c"], ["d", "e", "f"]]), ["a", "b", "c", "d", "e", "f"])
 * ```
 */
export declare function flatten<A>(as: Iterable<Iterable<A>>): Iterable<A>;
/**
 * Splits an iterator into a group of iterators by the size of per group.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(group([1, 2, 3, 4, 5, 6, 7], 3), [
 *  [1, 2, 3],
 *  [4, 5, 6],
 *  [7],
 * ])
 * ```
 */
export declare const group: <T>(ma: Iterable<T>, size: number) => Iterable<Iterable<T>>;
/**
 * Returns an iterator that concatenates the function result into a single interator (like [`flatten`](#flatten)).
 *
 * @example
 *
 * ```ts
 * const f = (n: number) => flow(replicate, collect)(`${n}`, n)
 *
 * assert.deepStrictEqual(pipe([1,2,3], map(f), collect), [['1'],['2','2'],['3','3','3']])
 * assert.deepStrictEqual(pipe([1,2,3], chain(f), collect), ['1','2','2','3','3','3'])
 * ```
 */
export declare const chain: <A, B>(f: (a: A, i: number) => Iterable<B>) => (as: Iterable<A>) => Iterable<B>;
/**
 * Depth-first chainRec.
 *
 * Chains until the next iterable is empty.
 *
 * @example
 *
 * ```ts
 * const f = (n: number) => n < 5 ? [right(n), left(n + 1)] : [right(n)]
 * assert.deepStrictEqual(pipe(1, chainRec(f), collect), [1, 2, 3, 4, 5])
 *
 * const f2 = (n: number) => n < 5 ? [left(n + 1), right(n)] : [right(n)]
 * assert.deepStrictEqual(pipe(1, chainRec(f2), collect), [5, 4, 3, 2, 1])
 * ```
 */
export declare const chainRec: <A, B>(f: (a: A) => Iterable<Either<A, B>>) => (a: A) => Iterable<B>;
/**
 * Creates an `Iter` from an iterator.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(iter([1]), new Iter(() => [1]))
 * ```
 */
export declare const iter: <A>(ma: Iterable<A> | (() => Iterable<A>)) => Iter<A>;
/**
 * Iter
 */
export declare class Iter<A> implements Iterable<A> {
    private readonly _iter;
    constructor(_iter: () => Iterable<A>);
    [Symbol.iterator](): Iterator<A>;
    get arr(): A[];
    static zero: <A_1>() => Iter<A_1>;
    static of: <A_1>(...args: A_1[]) => Iter<A_1>;
    static to: (end: number, step?: number | undefined) => Iter<number>;
    static range: (from: number, end: number, step?: number | undefined) => Iter<number>;
    static makeBy: <A_1>(n: number, f: (i: number) => A_1) => Iter<A_1>;
    static replicate: <A_1>(ma: A_1, n: number) => Iter<A_1>;
    head: () => import("./Maybe").None | import("./Maybe").Some<A>;
    tryHead: () => A | undefined;
    tail: () => Maybe<A>;
    tryTail: () => A | undefined;
    map: <B>(f: (a: A) => B) => Iter<B>;
    toArray: () => A[];
    isEmpty: () => boolean;
    push: (...as: A[]) => Iter<A>;
    unshift: (...as: A[]) => Iter<A>;
    filter: (predicate: Predicate<A>) => Iter<A>;
    reduce: <B>(f: (b: B, a: A) => B, b: B) => B;
    collect: () => A[];
    join: (seperator?: string) => string;
    count: () => number;
    zipWith: <B, C>(b: Iterable<B>, f: (a: A, b: B) => C) => Iter<C>;
    zip: <B>(b: Iterable<B>) => Iter<[A, B]>;
    unzip: () => Iter<[(A extends [infer X, any] | readonly [infer X, any] | (infer X)[] ? X : unknown)[], (A extends [any, infer Y] | readonly [any, infer Y] | (infer Y)[] ? Y : unknown)[]]>;
    flatten: () => A extends Iterable<infer R> ? Iter<R> : never;
    group: (size: number) => Iter<Iterable<A>>;
    chain: <B>(f: (a: A, i: number) => Iterable<B>) => Iter<B>;
    concat: <B>(...items: Iterable<B>[]) => Iter<A | Iterable<B>>;
    ap: <B>(ma: A extends (a: B) => any ? Iterable<B> : never) => Iter<A extends (a: B) => any ? ReturnType<A> : never>;
    alt: <B>(that: Lazy<Iterable<B>>) => Iter<A | B>;
}
/**
 * Alternative Functor
 */
export declare const Alternative: Alternative1<IterKind>;
/**
 * Monad Functor
 */
export declare const Monad: Monad1<IterKind>;
/**
 * ChainRec Functor
 */
export declare const ChainRec: ChainRec1<IterKind>;