import { Either } from './Either';
import { Lazy } from './function';
import { Alternative1 } from './Functors/Alternative';
import { Chain1 } from './Functors/Chain';
import { Extend1 } from './Functors/Extend';
import { Monad1 } from './Functors/Monad';
import { PipeableTraverse1, Traversable1 } from './Functors/Traversable';
import { Predicate } from './Predicate';
import { Refinement } from './Refinement';
export interface None {
    readonly _tag: 'None';
}
export interface Some<A> {
    readonly _tag: 'Some';
    readonly value: A;
}
export declare type Maybe<A> = None | Some<A>;
export declare const MaybeKind: unique symbol;
export declare type MaybeKind = typeof MaybeKind;
declare module './Functors/HKT' {
    interface Kinded<T> {
        readonly [MaybeKind]: Maybe<T[0]>;
    }
}
/**
 * Returns whether the maybe is `None` or not.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(isNone(none), true)
 * assert.deepStrictEqual(isNone(some(1)), false)
 * ```
 */
export declare const isNone: <A>(ma: Maybe<A>) => ma is None;
/**
 * Returns whether the maybe is `Some` or not.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(isSome(some(1)), true)
 * assert.deepStrictEqual(isSome(none), false)
 * ```
 */
export declare const isSome: <A>(ma: Maybe<A>) => ma is Some<A>;
/**
 * `None` value. Represents a missing value.
 */
export declare const none: Maybe<never>;
/**
 * Constructs a `Some`. Represents an optional value that exists.
 */
export declare const some: <A>(value: A) => Maybe<A>;
/**
 * Returns `Some` or `None` based on the given predicate.
 *
 * @example
 *
 * ```ts
 * const getMaybe = fromPredicate((n: number) => n > 0)
 *
 * assert.deepStrictEqual(getMaybe(-1), none)
 * assert.deepStrictEqual(getMaybe(1), some(1))
 * ```
 */
export declare function fromPredicate<A, B extends A>(Refinement: Refinement<A, B>): (a: A) => Maybe<B>;
export declare function fromPredicate<A>(predicate: Predicate<A>): <B extends A>(b: B) => Maybe<B>;
export declare function fromPredicate<A>(predicate: Predicate<A>): (a: A) => Maybe<A>;
/**
 * Transforms the `Maybe` with a given function. Returns `None` if the `Maybe` is `None`.
 */
export declare const map: <A, B>(f: (a: A) => B) => (fa: Maybe<A>) => Maybe<B>;
/**
 * Takes a value and wraps it into a `Some`.
 */
export declare const of: <A>(value: A) => Maybe<A>;
/**
 * Returns the `Maybe` if it is `Some`, otherwise returns the function result.
 */
export declare const alt: <B>(that: Lazy<Maybe<B>>) => <A>(ma: Maybe<A>) => Maybe<B | A>;
/**
 * Applies a `Some` function over a `Some` value. Returns `None` if the `Maybe` or the function is `None`.
 */
export declare const ap: <A>(ma: Maybe<A>) => <B>(fab: Maybe<(a: A) => B>) => Maybe<B>;
/**
 * Returns `None`.
 */
export declare const empty: () => None;
/**
 * Alias of `empty`.
 */
export declare const zero: () => None;
/**
 * Takes a predicate function and a `Maybe`, returns the `Maybe` if it's `Some` and the predicate returns true, otherwise returns `None`.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *  filter((n: number) => n > 0)
 * )
 *
 * assert.deepStrictEqual(f(some(1)), some(1))
 * assert.deepStrictEqual(f(some(0)), none)
 * assert.deepStrictEqual(none, none)
 * ```
 */
export declare const filter: <A>(predicate: Predicate<A>) => (ma: Maybe<A>) => Maybe<A>;
/**
 * Returns the onNone default value if the `Maybe` is `None`, otherwise returns the onSome function result with `Maybe`.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   match(() => 0, (n: number) => n + 1)
 * )
 *
 * assert.deepStrictEqual(f(some(1)), 2)
 * assert.deepStrictEqual(f(none), 1)
 * ```
 */
export declare const match: <B, A, C>(onNone: Lazy<B>, onSome: (a: A) => C) => (ma: Maybe<A>) => B | C;
/**
 * Composes computations in sequence. Useful for chaining many computations that may result in a missing value.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   chain((n: number) => some(n + 1)
 * )
 *
 * assert.deepStrictEqual(f(some(1)), some(2))
 * assert.deepStrictEqual(f(none), none)
 * ```
 */
export declare const chain: <A, B>(f: (a: A) => Maybe<B>) => (ma: Maybe<A>) => Maybe<B>;
/**
 * Returns none if the `Maybe` is a `None`, otherwise returns the result of the applying function and wrapped in a `Some`.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe(some(1), extend(getOrElse(zero))), some(1))
 * assert.deepStrictEqual(pipe(none, extend(getOrElse(zero))), none)
 * ```
 */
export declare const extend: <A, B>(f: (a: Maybe<A>) => B) => (ma: Maybe<A>) => Maybe<B>;
/**
 * Returns a `Right` from a `Some` or a `Left` with a default left value if `Maybe` is `None`.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   () => 0
 * )
 *
 * assert.deepStrictEqual(f(some(1)), right(1))
 * assert.deepStrictEqual(f(none), left(0))
 * ```
 */
export declare const toEither: <E>(f: Lazy<E>) => <A>(ma: Maybe<A>) => Either<E, A>;
/**
 * Extracts the value out of `Maybe` if it exists, otherwise returns `null`.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   toNullable
 * )
 *
 * assert.deepStrictEqual(f(some(1)), 1)
 * assert.deepStrictEqual(f(none), null)
 * ```
 */
export declare const toNullable: <A>(ma: Maybe<A>) => A | null;
/**
 * Extracts the value out of `Maybe` if it exists, otherwise returns `undefined`.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   toUndefined
 * )
 *
 * assert.deepStrictEqual(f(some(1)), 1)
 * assert.deepStrictEqual(f(none), undefined)
 * ```
 */
export declare const toUndefined: <A>(ma: Maybe<A>) => A | undefined;
/**
 * Extracts the value of `Maybe` if it exists, otherwise returns then default onNone value.
 *
 * @example
 *
 * ```ts
 * const f = flow(
 *   getOrElse(() => 0)
 * )
 *
 * assert.deepStrictEqual(f(some(1)), 1)
 * assert.deepStrictEqual(f(none)), 0)
 * ```
 */
export declare const getOrElse: <A>(onNone: Lazy<A>) => <B>(ma: Maybe<B>) => A | B;
/**
 * Returns `Maybe` if it's a `Some`, otherwise returns onNone result.
 *
 * @example
 * const f = flow(
 *   orElse(() => some(1))
 * )
 *
 * assert.deepStrictEqual(f(some(0)), some(0))
 * assert.deepStrictEqual(f(none), some(1))
 */
export declare const orElse: <B>(onNone: Lazy<Maybe<B>>) => <A>(ma: Maybe<A>) => Maybe<B | A>;
/**
 * Returns a `Maybe` from a function that might throw.
 *
 * @example
 *
 * ```ts
 * const unsafeDiv = (top: number, bottom: number) => {
 *   if(bottom === 0) throw new Error('unsafe division')
 *   return top / bottom
 * }
 * const div = (top: number, bottom: number) =>
 *   tryCatch(() => unsafeDiv(top, bottom))
 *
 * assert.deepStrictEqual(div(2, 0), none)
 * assert.deepStrictEqual(div(2, 1), some(2))
 * ```
 */
export declare const tryCatch: <A>(f: Lazy<A>) => Maybe<A>;
/**
 * Maps each element of a `HKT` structure to an action, and collects the results wrapped in `Some`.
 *
 * Returns a `HKT` contains a none if the `Maybe` is a `None`.
 *
 * @example
 *
 * ```ts
 * const f = traverse(Maybe.Monad)((n: number) => n > 0 ? some(n): none)
 * assert.deepStrictEqual(pipe(some(1), f), some(some(1)))
 * assert.deepStrictEqual(pipe(none, f), some(none))
 * assert.deepStrictEqual(pipe(some(-1), f), none)
 * ```
 */
export declare const traverse: PipeableTraverse1<MaybeKind>;
/**
 * Takes a function and an initial value and returns the initial value if `Maybe` is `none`,
 * otherwise returns the result of applying the function to the initial value and the value inside `Maybe`.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(pipe(some(1), reduce((acc, a) => acc + a, 1), 2)
 * assert.deepStrictEqual(pipe(none, reduce((acc, a) => acc + a, 1), 1)
 * ```
 */
export declare const reduce: <A, B>(f: (acc: B, a: A) => B, b: B) => (ma: Maybe<A>) => B;
/**
 * Compares one `Maybe` to another `Maybe`. Returns false if maybes or the wrapped values are different.
 *
 * @example
 *
 * ```ts
 * assert.deepStrictEqual(equals(some(1), some(1)), true)
 * assert.deepStrictEqual(equals(some(2), some(1)), false)
 * assert.deepStrictEqual(equals(some(1), none), false)
 * assert.deepStrictEqual(equals(none, none), true)
 * assert.deepStrictEqual(equals(none, right(1)), false)
 * ```
 */
export declare const equals: <A>(a: Maybe<A>, b: Maybe<A>) => boolean;
/**
 * Alternative Functor
 */
export declare const Alternative: Alternative1<MaybeKind>;
/**
 * Monad Functor
 */
export declare const Monad: Monad1<MaybeKind>;
/**
 * Chain Functor
 */
export declare const Chain: Chain1<MaybeKind>;
/**
 * Extend Functor
 */
export declare const Extend: Extend1<MaybeKind>;
/**
 * Traversable Functor
 */
export declare const Traversable: Traversable1<MaybeKind>;