Interface Maybe<T>

Maybe

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

apTo

bind

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

contains

  • contains(val: T): boolean

  • Parameters

    • val: T

    Returns boolean

equals

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)): monet.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 monet.Maybe<U>

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

  • Parameters

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

        • Parameters

          • val: T

          Returns boolean

    Returns monet.Maybe<T>

filterNot

  • filterNot<U extends {}>(fn: ((val: T) => val is U)): monet.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 monet.Maybe<Exclude<T, U>>

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

  • Parameters

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

        • Parameters

          • val: T

          Returns boolean

    Returns monet.Maybe<T>

flatMap

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 monet.Maybe<V>
        ? V
        : never

  • Type Parameters

    • V

    Returns T extends monet.Maybe<V>
        ? V
        : never

just

  • just(): T

  • Returns T

map

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

  • Type Parameters

    • V extends {}

    Parameters

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

        • Parameters

          • val: T

          Returns V

    Returns monet.Maybe<V>

orElse

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): monet.Maybe<T>

  • Parameters

    • val: boolean

    Returns monet.Maybe<T>

orNothingIf

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

  • Parameters

    • val: boolean

    Returns monet.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): monet.Either<E, T>

  • Type Parameters

    • E

    Parameters

    • Optional left: E

    Returns monet.Either<E, T>

toList

toSet

  • toSet(): Set<T>

  • Returns Set<T>

toValidation

Settings

Member Visibility

Theme

On This Page

[iterator]apapTobindcatacatchMapchaincontainsequalseveryexistsfantasy-land/equalsfilterfilterNotflatMapfoldfoldLeftfoldRightforEachforallgetOrElseisJustisNoneisNothingisSomejoinjustmaporElseorElseRunorJustorLazyorNoneIforNothingIforNullorSomeorUndefinedsometakeLefttakeRighttotoArraytoEithertoListtoSettoValidation