Interface Maybe<T>

Maybe

interface Maybe<T extends NonNullable<{}>> {
    [iterator](): Iterator<T, any, undefined>;
    ap<V extends {}>(maybeFn: Maybe<((val: T) => V)>): Maybe<V>;
    apTo<V extends {}>(value: Maybe<V>): T extends ((arg: V) => any)
        ? Maybe<ReturnType<T<T>>>
        : never;
    bind<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>;
    cata<Z>(none: (() => Z), some: ((val: T) => Z)): Z;
    catchMap(fn: (() => Maybe<T>)): Maybe<T>;
    chain<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>;
    contains(val: T): boolean;
    equals(other: Maybe<T>): boolean;
    every(fn: ((e: T) => boolean)): boolean;
    exists(fn: ((e: T) => boolean)): boolean;
    fantasy-land/equals?(other: Maybe<T>): boolean;
    filter<U extends {}>(fn: ((val: T) => val is U)): Maybe<U>;
    filter(fn: ((val: T) => boolean)): Maybe<T>;
    filterNot<U extends {}>(fn: ((val: T) => val is U)): Maybe<Exclude<T, U>>;
    filterNot(fn: ((val: T) => boolean)): Maybe<T>;
    flatMap<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>;
    fold<V>(val: V): ((fn: ((val: T) => V)) => V);
    foldLeft<V>(initial: V): ((fn: ((acc: V, val: T) => V)) => V);
    foldRight<V>(initial: V): ((fn: ((val: T, acc: V) => V)) => V);
    forEach(fn: ((val: T) => void)): void;
    forall(fn: ((e: T) => boolean)): boolean;
    getOrElse(val: T): T;
    isJust(): boolean;
    isNone(): boolean;
    isNothing(): boolean;
    isSome(): boolean;
    join<V>(): T extends Maybe<V>
        ? V
        : never;
    just(): T;
    map<V extends {}>(fn: ((val: T) => V)): Maybe<V>;
    orElse(maybe: Maybe<T>): Maybe<T>;
    orElseRun(fn: (() => void)): void;
    orJust(val: T): T;
    orLazy(fn: (() => undefined | null | T)): T;
    orNoneIf(val: boolean): Maybe<T>;
    orNothingIf(val: boolean): Maybe<T>;
    orNull(): null | T;
    orSome(val: T): T;
    orUndefined(): undefined | T;
    some(): T;
    takeLeft(m: Maybe<T>): Maybe<T>;
    takeRight(m: Maybe<T>): Maybe<T>;
    to<I extends Iterable<T>>(ctor: ((iter: Iterable<T>) => I)): I;
    toArray(): T[];
    toEither<E>(left?: E): Either<E, T>;
    toList(): List<T>;
    toSet(): Set<T>;
    toValidation<E>(fail?: E): Validation<E, T>;
}

Type Parameters

Hierarchy-Diagram

UML class diagram of Maybe
Legend
icon for an interface in the UML class diagram interface
icon for a public method in the UML class diagram public method

Hierarchy (view full)

Methods

[iterator] ap apTo bind cata catchMap chain contains equals every exists fantasy-land/equals? filter filterNot flatMap fold foldLeft foldRight forEach forall getOrElse isJust isNone isNothing isSome join just map orElse orElseRun orJust orLazy orNoneIf orNothingIf orNull orSome orUndefined some takeLeft takeRight to toArray toEither toList toSet toValidation

Methods

[iterator]

ap

  • ap<V extends {}>(maybeFn: Maybe<((val: T) => V)>): Maybe<V>

  • Type Parameters

    • V extends {}

    Parameters

    Returns Maybe<V>

apTo

  • apTo<V extends {}>(value: Maybe<V>): T extends ((arg: V) => any)
        ? Maybe<ReturnType<T<T>>>
        : never

  • Type Parameters

    • V extends {}

    Parameters

    Returns T extends ((arg: V) => any)
        ? Maybe<ReturnType<T<T>>>
        : never

bind

  • bind<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>

  • Type Parameters

    • V extends {}

    Parameters

    Returns Maybe<V>

cata

  • cata<Z>(none: (() => Z), some: ((val: T) => Z)): Z

  • Type Parameters

    • Z

    Parameters

    • none: (() => Z)
        • (): Z

        • Returns Z

    • some: ((val: T) => Z)
        • (val: T): Z

        • Parameters

          • val: T

          Returns Z

    Returns Z

catchMap

chain

  • chain<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>

  • Type Parameters

    • V extends {}

    Parameters

    Returns Maybe<V>

contains

  • contains(val: T): boolean

  • Parameters

    • val: T

    Returns boolean

equals

  • equals(other: Maybe<T>): boolean

  • Parameters

    Returns boolean

every

  • every(fn: ((e: T) => boolean)): boolean

  • Parameters

    • fn: ((e: T) => boolean)
        • (e: T): boolean

        • Parameters

          Returns boolean

    Returns boolean

exists

  • exists(fn: ((e: T) => boolean)): boolean

  • Parameters

    • fn: ((e: T) => boolean)
        • (e: T): boolean

        • Parameters

          Returns boolean

    Returns boolean

Optional fantasy-land/equals

filter

  • filter<U extends {}>(fn: ((val: T) => val is U)): Maybe<U>

  • Type Parameters

    • U extends {}

    Parameters

    • fn: ((val: T) => val is U)
        • (val: T): val is U

        • Parameters

          • val: T

          Returns val is U

    Returns Maybe<U>

  • filter(fn: ((val: T) => boolean)): Maybe<T>

  • Parameters

    • fn: ((val: T) => boolean)
        • (val: T): boolean

        • Parameters

          • val: T

          Returns boolean

    Returns Maybe<T>

filterNot

  • filterNot<U extends {}>(fn: ((val: T) => val is U)): Maybe<Exclude<T, U>>

  • Type Parameters

    • U extends {}

    Parameters

    • fn: ((val: T) => val is U)
        • (val: T): val is U

        • Parameters

          • val: T

          Returns val is U

    Returns Maybe<Exclude<T, U>>

  • filterNot(fn: ((val: T) => boolean)): Maybe<T>

  • Parameters

    • fn: ((val: T) => boolean)
        • (val: T): boolean

        • Parameters

          • val: T

          Returns boolean

    Returns Maybe<T>

flatMap

  • flatMap<V extends {}>(fn: ((val: T) => Maybe<V>)): Maybe<V>

  • Type Parameters

    • V extends {}

    Parameters

    Returns Maybe<V>

fold

  • fold<V>(val: V): ((fn: ((val: T) => V)) => V)

  • Type Parameters

    • V

    Parameters

    • val: V

    Returns ((fn: ((val: T) => V)) => V)

      • (fn: ((val: T) => V)): V

      • Parameters

        • fn: ((val: T) => V)
            • (val: T): V

            • Parameters

              • val: T

              Returns V

        Returns V

foldLeft

  • foldLeft<V>(initial: V): ((fn: ((acc: V, val: T) => V)) => V)

  • Type Parameters

    • V

    Parameters

    • initial: V

    Returns ((fn: ((acc: V, val: T) => V)) => V)

      • (fn: ((acc: V, val: T) => V)): V

      • Parameters

        • fn: ((acc: V, val: T) => V)
            • (acc: V, val: T): V

            • Parameters

              • acc: V
              • val: T

              Returns V

        Returns V

foldRight

  • foldRight<V>(initial: V): ((fn: ((val: T, acc: V) => V)) => V)

  • Type Parameters

    • V

    Parameters

    • initial: V

    Returns ((fn: ((val: T, acc: V) => V)) => V)

      • (fn: ((val: T, acc: V) => V)): V

      • Parameters

        • fn: ((val: T, acc: V) => V)
            • (val: T, acc: V): V

            • Parameters

              • val: T
              • acc: V

              Returns V

        Returns V

forEach

  • forEach(fn: ((val: T) => void)): void

  • Parameters

    • fn: ((val: T) => void)
        • (val: T): void

        • Parameters

          • val: T

          Returns void

    Returns void

forall

  • forall(fn: ((e: T) => boolean)): boolean

  • Parameters

    • fn: ((e: T) => boolean)
        • (e: T): boolean

        • Parameters

          Returns boolean

    Returns boolean

getOrElse

  • getOrElse(val: T): T

  • Parameters

    • val: T

    Returns T

isJust

  • isJust(): boolean

  • Returns boolean

isNone

  • isNone(): boolean

  • Returns boolean

isNothing

  • isNothing(): boolean

  • Returns boolean

isSome

  • isSome(): boolean

  • Returns boolean

join

  • join<V>(): T extends Maybe<V>
        ? V
        : never

  • Type Parameters

    • V

    Returns T extends Maybe<V>
        ? V
        : never

just

  • just(): T

  • Returns T

map

  • map<V extends {}>(fn: ((val: T) => V)): Maybe<V>

  • Type Parameters

    • V extends {}

    Parameters

    • fn: ((val: T) => V)
        • (val: T): V

        • Parameters

          • val: T

          Returns V

    Returns Maybe<V>

orElse

  • orElse(maybe: Maybe<T>): Maybe<T>

  • Parameters

    Returns Maybe<T>

orElseRun

  • orElseRun(fn: (() => void)): void

  • Parameters

    • fn: (() => void)
        • (): void

        • Returns void

    Returns void

orJust

  • orJust(val: T): T

  • Parameters

    • val: T

    Returns T

orLazy

  • orLazy(fn: (() => undefined | null | T)): T

  • Parameters

    • fn: (() => undefined | null | T)
        • (): undefined | null | T

        • Returns undefined | null | T

    Returns T

orNoneIf

  • orNoneIf(val: boolean): Maybe<T>

  • Parameters

    • val: boolean

    Returns Maybe<T>

orNothingIf

  • orNothingIf(val: boolean): Maybe<T>

  • Parameters

    • val: boolean

    Returns Maybe<T>

orNull

  • orNull(): null | T

  • Returns null | T

orSome

  • orSome(val: T): T

  • Parameters

    • val: T

    Returns T

orUndefined

  • orUndefined(): undefined | T

  • Returns undefined | T

some

  • some(): T

  • Returns T

takeLeft

takeRight

to

toArray

  • toArray(): T[]

  • Returns T[]

toEither

  • toEither<E>(left?: E): Either<E, T>

  • Type Parameters

    • E

    Parameters

    • Optional left: E

    Returns Either<E, T>

toList

  • toList(): List<T>

  • Returns List<T>

toSet

  • toSet(): Set<T>

  • Returns Set<T>

toValidation

  • toValidation<E>(fail?: E): Validation<E, T>

  • Type Parameters

    • E

    Parameters

    • Optional fail: E

    Returns Validation<E, T>

Settings

Member Visibility

Theme

On This Page

[iterator]apapTobindcatacatchMapchaincontainsequalseveryexistsfantasy-land/equalsfilterfilterNotflatMapfoldfoldLeftfoldRightforEachforallgetOrElseisJustisNoneisNothingisSomejoinjustmaporElseorElseRunorJustorLazyorNoneIforNothingIforNullorSomeorUndefinedsometakeLefttakeRighttotoArraytoEithertoListtoSettoValidation