Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Filter<T, S>

Type parameters

  • T

  • S: T

Hierarchy

Index

Constructors

constructor

  • new Filter<T, S>(iter: Iterator<T, any, undefined>, fn: IFilterBooleanFn<T> | IFilterPredicateFn<T, S>): Filter<T, S>
  • Type parameters

    • T

    • S

    Parameters

    • iter: Iterator<T, any, undefined>
    • fn: IFilterBooleanFn<T> | IFilterPredicateFn<T, S>

    Returns Filter<T, S>

Properties

Protected _index

_index: number = 0

Protected _iter

_iter: Iterator<S, any, undefined>

Methods

[iterator]

  • [iterator](): IterableIterator<S>

all

  • all(fn: (value: S, index: number) => boolean): boolean
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns boolean

any

  • any(fn: (value: S, index: number) => boolean): boolean
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns boolean

concat

  • concat(iter: Iterator<S, any, undefined>): Merge<S>

consume

count

  • count(): number

enumerate

filter

  • filter<S>(fn: IFilterPredicateFn<S, S>): Filter<S, S>
  • filter(fn: IFilterBooleanFn<S>): Filter<S, S>

find

  • find(fn: (value: S, index: number) => boolean): Option<S>
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns Option<S>

findAll

  • findAll(fn: (value: S) => boolean): Filter<S, S>
  • Parameters

    • fn: (value: S) => boolean
        • (value: S): boolean
        • Parameters

          • value: S

          Returns boolean

    Returns Filter<S, S>

findIndex

  • findIndex(fn: (value: S, index: number) => boolean): number
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns number

first

forEach

  • forEach(fn: IForEachFn<S>): ForEach<S>

indexOf

  • indexOf(value: S): number

iter

join

  • join(separator?: string): string

last

map

  • map<B>(fn: IMapFn<S, B>): Map<S, B>

merge

  • merge(iter: Iterator<S, any, undefined>): Merge<S>

next

  • next(): IteratorResult<S, undefined>

nextWithIndex

  • nextWithIndex(): IteratorResult<[S, number], undefined>

none

  • none(fn: (value: S, index: number) => boolean): boolean
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns boolean

nth

  • nth(index?: number): Option<S>

peekable

reduce

  • reduce<C>(acc: C, fn: (acc: C, value: S, index: number) => C): C
  • Type parameters

    • C

    Parameters

    • acc: C
    • fn: (acc: C, value: S, index: number) => C
        • (acc: C, value: S, index: number): C
        • Parameters

          • acc: C
          • value: S
          • index: number

          Returns C

    Returns C

reverse

  • reverse(): Iter<S>

skip

  • skip(skip: number): Skip<S>

some

  • some(fn: (value: S, index: number) => boolean): boolean
  • Parameters

    • fn: (value: S, index: number) => boolean
        • (value: S, index: number): boolean
        • Parameters

          • value: S
          • index: number

          Returns boolean

    Returns boolean

step

  • step(step: number): Step<S>

take

  • take(count: number): Take<S>

toArray

  • toArray(): S[]

toMap

  • toMap<K, V>(keyFn?: IToMapFn<S, K>, valueFn?: IToMapFn<S, V>): ToMap<S, K, V>
  • Type parameters

    • K: string | number | symbol

    • V

    Parameters

    • Optional keyFn: IToMapFn<S, K>
    • Optional valueFn: IToMapFn<S, V>

    Returns ToMap<S, K, V>

unflatten

  • unflatten<U>(fn: UnflattenFn<S, U>): Unflatten<S, U>

Generated using TypeDoc