import { Monoid, MonoidConstructor } from "./monoid";
import { Applicative, ApplicativeDictionary } from "./applicative";
import { Monad } from "./monad";
import { Maybe } from "./maybe";
import { Either } from "./either";
export interface Foldable<A> {
    foldr<B>(f: (a: A, acc: B) => B, acc: B): B;
    foldl<B>(f: (acc: B, a: A) => B, init: B): B;
    shortFoldr<B>(f: (a: A, acc: B) => Either<B, B>, acc: B): B;
    shortFoldl<B>(f: (acc: B, a: A) => Either<B, B>, acc: B): B;
    size(): number;
    maximum(): number;
    minimum(): number;
    sum(): number;
}
export declare type AnyFoldable<A> = Foldable<A> | A[];
export declare abstract class AbstractFoldable<A> implements Foldable<A> {
    abstract foldr<B>(f: (a: A, acc: B) => B, init: B): B;
    foldl<B>(f: (acc: B, a: A) => B, init: B): B;
    shortFoldr<B>(f: (a: A, b: B) => Either<B, B>, acc: B): B;
    shortFoldl<B>(f: (b: B, a: A) => Either<B, B>, acc: B): B;
    size(): number;
    maximum(): number;
    minimum(): number;
    sum(): number;
}
export declare function foldable(constructor: Function): void;
export declare function foldMap<A, M extends Monoid<M>>(f: MonoidConstructor<A, M>, a: Foldable<A> | A[]): M;
export declare function foldr<A, B>(f: (a: A, b: B) => B, init: B, a: Foldable<A> | A[]): B;
export declare function foldl<A, B>(f: (acc: B, a: A) => B, init: B, a: Foldable<A> | A[]): B;
export declare function size(a: Foldable<any> | any[]): number;
export declare function isEmpty(a: AnyFoldable<any>): boolean;
export declare function take<A>(n: number, t: Foldable<A>): A[];
export declare function find<A>(f: (a: A) => boolean, t: Foldable<A>): Maybe<A>;
export declare function findLast<A>(f: (a: A) => boolean, t: Foldable<A>): Maybe<A>;
export declare function findIndex<A>(f: (a: A) => boolean, t: Foldable<A>): Maybe<number>;
export declare function findLastIndex<A>(f: (a: A) => boolean, t: Foldable<A>): Maybe<number>;
export declare function shortFoldl<A, B>(f: (b: B, a: A) => Either<B, B>, acc: B, l: Foldable<A>): B;
export declare function all<A>(pred: (a: A) => boolean, foldable: Foldable<A>): boolean;
export declare function any<A>(pred: (a: A) => boolean, foldable: Foldable<A>): boolean;
export declare function toArray<A>(t: Foldable<A> | A[]): A[];
export declare function sequence_(d: ApplicativeDictionary | ArrayConstructor, t: Foldable<Applicative<any>> | Array<Applicative<any>>): any;
export declare function foldrM<A, B>(f: (a: A, b: B) => Monad<B>, mb: Monad<B>, t: Foldable<A> | A[]): Monad<B>;
export declare function maximum(t: Foldable<number>): number;
export declare function minimum(t: Foldable<number>): number;
export declare function sum(t: Foldable<number>): number;