Interface Nil

List

interface Nil {
    @@type: string;
    [iterator](): Iterator<void, any, undefined>;
    ap<V>(listFn: monet.List<((val: void) => V)>): monet.List<V>;
    apTo<V>(listVal: monet.List<V>): never;
    append<T>(list: monet.List<T>): monet.List<T>;
    bind<V>(fn: ((val: void) => monet.List<V>)): monet.List<V>;
    chain<V>(fn: ((val: void) => monet.List<V>)): monet.List<V>;
    concat<T>(list: monet.List<T>): monet.List<T>;
    cons<T>(a: T): monet.List<T>;
    contains(val: void): boolean;
    equals(other: monet.List<void>): boolean;
    every(fn: ((e: void) => boolean)): boolean;
    exists(fn: ((e: void) => boolean)): boolean;
    fantasy-land/ap?<V>(afn: monet.Applicative<((val: void) => V)>): monet.Applicative<V>;
    fantasy-land/chain?<V>(fn: ((val: void) => monet.Chain<V>)): monet.Chain<V>;
    fantasy-land/equals?(other: monet.List<void>): boolean;
    fantasy-land/map?<V>(fn: ((val: void) => V)): monet.Functor<V>;
    filter(fn: ((val: void) => boolean)): monet.List<void>;
    filterNot(fn: ((val: void) => boolean)): monet.List<void>;
    find(fn: ((val: void) => boolean)): monet.Maybe<NonNullable<void>>;
    flatMap<V>(fn: ((val: void) => monet.List<V>)): monet.List<V>;
    flatten<V>(): monet.List<V>;
    flattenMaybe<V>(): never;
    foldLeft<V>(initial: V): ((fn: ((acc: V, val: void) => V)) => V);
    foldRight<V>(initial: V): ((fn: ((val: void, acc: V) => V)) => V);
    forEach(fn: ((val: void) => void)): void;
    forall(fn: ((e: void) => boolean)): boolean;
    head(): undefined | void;
    headMaybe(): monet.Maybe<NonNullable<void>>;
    isNEL(): boolean;
    join<V>(): monet.List<V>;
    lookup(i: number): monet.Maybe<void>;
    map<V>(fn: ((val: void) => V)): monet.List<V>;
    nth(i: number): undefined | void;
    reverse(): monet.List<void>;
    sequence<V>(m: monet.IMaybeStatic): monet.Maybe<monet.List<V>>;
    sequence<E, V>(m: monet.IEitherStatic): monet.Either<E, monet.List<V>>;
    sequence<E, V>(m: monet.IValidationStatic): monet.Validation<monet.List<E>, monet.List<V>>;
    sequence<V>(m: monet.IIOStatic): monet.IO<monet.List<V>>;
    sequence<E, A>(m: monet.IReaderStatic): monet.Reader<E, monet.List<A>>;
    sequenceEither<E, V>(): monet.Either<E, monet.List<V>>;
    sequenceIO<V>(): monet.IO<monet.List<V>>;
    sequenceMaybe<V>(): monet.Maybe<monet.List<V>>;
    sequenceReader<E, A>(): monet.Reader<E, monet.List<A>>;
    sequenceValidation<E, V>(): monet.Validation<monet.List<E>, monet.List<V>>;
    size(): number;
    snoc(a: void): monet.List<void>;
    tail(): monet.List<void>;
    tails(): monet.List<monet.List<void>>;
    takeLeft<V>(m: monet.List<V>): monet.List<void>;
    takeRight<V>(m: monet.List<V>): monet.List<V>;
    to<I extends Iterable<void>>(ctor: ((iter: Iterable<void>) => I)): I;
    toArray(): void[];
    toSet(): Set<void>;
}

Hierarchy-Diagram

UML class diagram of Nil
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)

Properties

@@type

Methods

[iterator] ap apTo append bind chain concat cons contains equals every exists fantasy-land/ap? fantasy-land/chain? fantasy-land/equals? fantasy-land/map? filter filterNot find flatMap flatten flattenMaybe foldLeft foldRight forEach forall head headMaybe isNEL join lookup map nth reverse sequence sequenceEither sequenceIO sequenceMaybe sequenceReader sequenceValidation size snoc tail tails takeLeft takeRight to toArray toSet

Properties

@@type

@@type: string

Methods

[iterator]

  • [iterator](): Iterator<void, any, undefined>

  • Returns Iterator<void, any, undefined>

ap

apTo

  • apTo<V>(listVal: monet.List<V>): never

  • Type Parameters

    • V

    Parameters

    Returns never

append

bind

chain

concat

cons

contains

  • contains(val: void): boolean

  • Parameters

    • val: void

    Returns boolean

equals

  • equals(other: monet.List<void>): boolean

  • Parameters

    Returns boolean

every

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

  • Parameters

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

        • Parameters

          • e: void

          Returns boolean

    Returns boolean

exists

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

  • Parameters

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

        • Parameters

          • e: void

          Returns boolean

    Returns boolean

Optional fantasy-land/ap

Optional fantasy-land/chain

Optional fantasy-land/equals

Optional fantasy-land/map

  • fantasy-land/map<V>(fn: ((val: void) => V)): monet.Functor<V>

  • Type Parameters

    • V

    Parameters

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

        • Parameters

          • val: void

          Returns V

    Returns monet.Functor<V>

filter

  • filter(fn: ((val: void) => boolean)): monet.List<void>

  • Parameters

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

        • Parameters

          • val: void

          Returns boolean

    Returns monet.List<void>

filterNot

  • filterNot(fn: ((val: void) => boolean)): monet.List<void>

  • Parameters

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

        • Parameters

          • val: void

          Returns boolean

    Returns monet.List<void>

find

  • find(fn: ((val: void) => boolean)): monet.Maybe<NonNullable<void>>

  • Parameters

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

        • Parameters

          • val: void

          Returns boolean

    Returns monet.Maybe<NonNullable<void>>

flatMap

flatten

flattenMaybe

  • flattenMaybe<V>(): never

  • Type Parameters

    • V

    Returns never

foldLeft

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

  • Type Parameters

    • V

    Parameters

    • initial: V

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

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

      • Parameters

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

            • Parameters

              • acc: V
              • val: void

              Returns V

        Returns V

foldRight

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

  • Type Parameters

    • V

    Parameters

    • initial: V

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

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

      • Parameters

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

            • Parameters

              • val: void
              • acc: V

              Returns V

        Returns V

forEach

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

  • Parameters

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

        • Parameters

          • val: void

          Returns void

    Returns void

forall

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

  • Parameters

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

        • Parameters

          • e: void

          Returns boolean

    Returns boolean

head

  • head(): undefined | void

  • Returns undefined | void

headMaybe

isNEL

  • isNEL(): boolean

  • Returns boolean

join

lookup

  • lookup(i: number): monet.Maybe<void>

  • Parameters

    • i: number

    Returns monet.Maybe<void>

map

  • map<V>(fn: ((val: void) => V)): monet.List<V>

  • Type Parameters

    • V

    Parameters

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

        • Parameters

          • val: void

          Returns V

    Returns monet.List<V>

nth

  • nth(i: number): undefined | void

  • Parameters

    • i: number

    Returns undefined | void

reverse

sequence

sequenceEither

sequenceIO

sequenceMaybe

sequenceReader

sequenceValidation

size

  • size(): number

  • Returns number

snoc

  • snoc(a: void): monet.List<void>

  • Parameters

    • a: void

    Returns monet.List<void>

tail

tails

takeLeft

takeRight

to

toArray

  • toArray(): void[]

  • Returns void[]

toSet

  • toSet(): Set<void>

  • Returns Set<void>

Settings

Member Visibility

Theme

On This Page

@@type[iterator]apapToappendbindchainconcatconscontainsequalseveryexistsfantasy-land/apfantasy-land/chainfantasy-land/equalsfantasy-land/mapfilterfilterNotfindflatMapflattenflattenMaybefoldLeftfoldRightforEachforallheadheadMaybeisNELjoinlookupmapnthreversesequencesequenceEithersequenceIOsequenceMaybesequenceReadersequenceValidationsizesnoctailtailstakeLefttakeRighttotoArraytoSet