import { Monoid } from "./monoid";
import { Applicative, ApplicativeDictionary } from "./applicative";
import { Traversable } from "./traversable";
import { Monad } from "./monad";
import { Either } from "./either";
export declare class Cons<A> implements Monoid<Cons<A>>, Monad<A>, Traversable<A> {
    private val;
    private tail;
    constructor(val: A, tail: Cons<A>);
    combine(c: Cons<A>): Cons<A>;
    identity(): Cons<any>;
    of<B>(b: B): Cons<B>;
    chain<B>(f: (a: A) => Cons<B>): Cons<B>;
    traverse<B>(a: ApplicativeDictionary, f: (a: A) => Applicative<B>): Applicative<Cons<B>>;
    map: <B>(f: (a: A) => B) => Cons<B>;
    mapTo: <B>(b: B) => Cons<B>;
    ap: <B>(a: Monad<(a: A) => B>) => Cons<B>;
    lift: (f: Function, ...ms: any[]) => Cons<any>;
    multi: boolean;
    flatten: () => Cons<A>;
    foldr: <B>(f: (a: A, b: B) => B, acc: B) => B;
    foldl: <B>(f: (acc: B, a: A) => B, init: B) => B;
    sequence: <A>(a: ApplicativeDictionary, t: Cons<Applicative<A>>) => Applicative<Traversable<A>>;
    shortFoldr: <B>(f: (a: A, b: 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 const nil: Cons<any>;
export declare function cons<A>(a: A, as: Cons<A>): Cons<A>;
export declare function fromArray<A>(as: A[]): Cons<A>;