Options
All
  • Public
  • Public/Protected
  • All
Menu

Class ForEach<T>

Type parameters

  • T

Hierarchy

Index

Constructors

constructor

  • new ForEach<T>(iter: Iterator<T, any, undefined>, fn: IForEachFn<T>): ForEach<T>

Properties

Protected _index

_index: number = 0

Protected _iter

_iter: Iterator<T, any, undefined>

Methods

[iterator]

  • [iterator](): IterableIterator<T>

all

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

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

          • value: T
          • index: number

          Returns boolean

    Returns boolean

any

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

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

          • value: T
          • index: number

          Returns boolean

    Returns boolean

concat

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

consume

count

  • count(): number

enumerate

filter

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

find

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

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

          • value: T
          • index: number

          Returns boolean

    Returns Option<T>

findAll

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

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

          • value: T

          Returns boolean

    Returns Filter<T, T>

findIndex

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

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

          • value: T
          • index: number

          Returns boolean

    Returns number

first

forEach

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

indexOf

  • indexOf(value: T): number

iter

join

  • join(separator?: string): string

last

map

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

merge

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

next

  • next(): IteratorResult<T, undefined>

nextWithIndex

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

none

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

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

          • value: T
          • index: number

          Returns boolean

    Returns boolean

nth

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

peekable

reduce

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

    • C

    Parameters

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

          • acc: C
          • value: T
          • index: number

          Returns C

    Returns C

reverse

  • reverse(): Iter<T>

skip

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

some

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

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

          • value: T
          • index: number

          Returns boolean

    Returns boolean

step

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

take

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

toArray

  • toArray(): T[]

toMap

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

    • K: string | number | symbol

    • V

    Parameters

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

    Returns ToMap<T, K, V>

unflatten

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

Generated using TypeDoc