import { Applicative, ApplicativeDictionary } from "./applicative";
import { Traversable } from "./traversable";
import { Monad } from "./monad";
import { Either } from "./either";
export declare type MaybeMatch<T, K> = {
    nothing: () => K;
    just: (t: T) => K;
};
export declare abstract class Maybe<A> implements Monad<A>, Traversable<A> {
    abstract match<K>(m: MaybeMatch<A, K>): K;
    of<B>(v: B): Maybe<B>;
    static of<B>(v: B): Maybe<B>;
    abstract chain<B>(f: (a: A) => Maybe<B>): Maybe<B>;
    flatten<B>(): Maybe<any>;
    abstract map<B>(f: (a: A) => B): Maybe<B>;
    abstract mapTo<B>(b: B): Maybe<B>;
    abstract ap<B>(a: Applicative<(a: A) => B>): Applicative<B>;
    lift<T1, R>(f: (t: T1) => R, m: Maybe<T1>): Maybe<R>;
    lift<T1, T2, R>(f: (t: T1, u: T2) => R, m1: Maybe<T1>, m2: Maybe<T2>): Maybe<R>;
    lift<T1, T2, T3, R>(f: (t1: T1, t2: T2, t3: T3) => R, m1: Maybe<T1>, m2: Maybe<T2>, m3: Maybe<T3>): Maybe<R>;
    abstract foldr<B>(acc: B, f: (a: A, b: B) => B): B;
    abstract 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: (acc: B, a: A) => Either<B, B>, acc: B) => B;
    maximum: () => number;
    minimum: () => number;
    sum: () => number;
    abstract size(): number;
    abstract traverse<B>(a: ApplicativeDictionary, f: (a: A) => Applicative<B>): Applicative<Traversable<B>>;
    sequence<A>(a: ApplicativeDictionary, m: Maybe<Applicative<A>>): Applicative<Traversable<A>>;
    static multi: boolean;
    multi: boolean;
}
export declare function just<V>(v: V): Maybe<V>;
export declare const nothing: Maybe<any>;
export declare function isNothing(m: Maybe<any>): boolean;
export declare function isJust(m: Maybe<any>): boolean;
export declare function fromMaybe<A>(a: A, m: Maybe<A>): A;
export declare function maybe<A, B>(b: B, f: (a: A) => B, m: Maybe<A>): B;