Options
All
  • Public
  • Public/Protected
  • All
Menu

Class ToMap<T, K, V>

Type parameters

  • T

  • K: string | number | symbol

  • V

Hierarchy

  • Iter<[K, V]>
    • ToMap

Index

Constructors

constructor

  • new ToMap<T, K, V>(iter: Iterator<T, any, undefined>, keyFn?: IToMapFn<T, K>, valueFn?: IToMapFn<T, V>): ToMap<T, K, V>
  • Type parameters

    • T

    • K: string | number | symbol

    • V

    Parameters

    • iter: Iterator<T, any, undefined>
    • keyFn: IToMapFn<T, K> = ...
    • valueFn: IToMapFn<T, V> = ...

    Returns ToMap<T, K, V>

Properties

Protected _index

_index: number = 0

Protected _iter

_iter: Iterator<[K, V], any, undefined>

Methods

[iterator]

  • [iterator](): IterableIterator<[K, V]>

all

  • all(fn: (value: [K, V], index: number) => boolean): boolean
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns boolean

any

  • any(fn: (value: [K, V], index: number) => boolean): boolean
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns boolean

concat

  • concat(iter: Iterator<[K, V], any, undefined>): Merge<[K, V]>

consume

  • consume(): ToMap<T, K, V>

count

  • count(): number

enumerate

filter

  • filter<S>(fn: IFilterPredicateFn<[K, V], S>): Filter<[K, V], S>
  • filter(fn: IFilterBooleanFn<[K, V]>): Filter<[K, V], [K, V]>

find

  • find(fn: (value: [K, V], index: number) => boolean): Option<[K, V]>
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns Option<[K, V]>

findAll

  • findAll(fn: (value: [K, V]) => boolean): Filter<[K, V], [K, V]>
  • Parameters

    • fn: (value: [K, V]) => boolean
        • (value: [K, V]): boolean
        • Parameters

          • value: [K, V]

          Returns boolean

    Returns Filter<[K, V], [K, V]>

findIndex

  • findIndex(fn: (value: [K, V], index: number) => boolean): number
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns number

first

forEach

  • forEach(fn: IForEachFn<[K, V]>): ForEach<[K, V]>

indexOf

  • indexOf(value: [K, V]): number

iter

  • iter(): Iter<[K, V]>

join

  • join(separator?: string): string

last

map

  • map<B>(fn: IMapFn<[K, V], B>): Map<[K, V], B>
  • Type parameters

    • B

    Parameters

    • fn: IMapFn<[K, V], B>

    Returns Map<[K, V], B>

merge

  • merge(iter: Iterator<[K, V], any, undefined>): Merge<[K, V]>

next

  • next(): IteratorResult<[K, V], undefined>

nextWithIndex

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

none

  • none(fn: (value: [K, V], index: number) => boolean): boolean
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns boolean

nth

  • nth(index?: number): Option<[K, V]>

peekable

reduce

  • reduce<C>(acc: C, fn: (acc: C, value: [K, V], index: number) => C): C
  • Type parameters

    • C

    Parameters

    • acc: C
    • fn: (acc: C, value: [K, V], index: number) => C
        • (acc: C, value: [K, V], index: number): C
        • Parameters

          • acc: C
          • value: [K, V]
          • index: number

          Returns C

    Returns C

reverse

  • reverse(): Iter<[K, V]>

skip

  • skip(skip: number): Skip<[K, V]>

some

  • some(fn: (value: [K, V], index: number) => boolean): boolean
  • Parameters

    • fn: (value: [K, V], index: number) => boolean
        • (value: [K, V], index: number): boolean
        • Parameters

          • value: [K, V]
          • index: number

          Returns boolean

    Returns boolean

step

  • step(step: number): Step<[K, V]>

take

  • take(count: number): Take<[K, V]>

toArray

  • toArray(): [K, V][]

toMap

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

    • K: string | number | symbol

    • V

    Parameters

    • Optional keyFn: IToMapFn<[K, V], K>
    • Optional valueFn: IToMapFn<[K, V], V>

    Returns ToMap<[K, V], K, V>

toObject

  • toObject(): Record<K, V>

unflatten

  • unflatten<U>(fn: UnflattenFn<[K, V], U>): Unflatten<[K, V], U>

Generated using TypeDoc