Class AsyncMap<A, B>

Type Parameters

A
B

Hierarchy

AsyncIter<B>
- AsyncMap

Index

Constructors

Properties

Constructors

constructor

new AsyncMap<A, B>(iter: AsyncIterator<A, any, undefined>, fn: IAsyncMapFn<A, B>): AsyncMap<A, B>
Type Parameters
- A
- B
Parameters
- iter: AsyncIterator<A, any, undefined>
- fn: IAsyncMapFn<A, B>
Returns AsyncMap<A, B>
Overrides AsyncIter.constructor
- Defined in async/AsyncMap.ts:8

Properties

`Protected` _index

_index: number = 0

`Protected` _iter

_iter: AsyncIterator<B, any, undefined>

Methods

[asyncIterator]

[asyncIterator](): AsyncIter<B>
Returns AsyncIter<B>
Inherited from AsyncIter.[asyncIterator]
- Defined in async/AsyncIter.ts:34

all

all(fn: ((value: B, index: number) => boolean)): Promise<boolean>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<boolean>
Inherited from AsyncIter.all
- Defined in async/AsyncIter.ts:249

any

any(fn: ((value: B, index: number) => boolean)): Promise<boolean>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<boolean>
Inherited from AsyncIter.any
- Defined in async/AsyncIter.ts:239

concat

concat(iter: AsyncIterator<B, any, undefined>): AsyncMerge<B>
Parameters
- iter: AsyncIterator<B, any, undefined>
Returns AsyncMerge<B>
Inherited from AsyncIter.concat
- Defined in async/AsyncIter.ts:81

consume

consume(): Promise<AsyncMap<A, B>>
Returns Promise<AsyncMap<A, B>>
Inherited from AsyncIter.consume
- Defined in async/AsyncIter.ts:132

count

count(): Promise<number>
Returns Promise<number>
Inherited from AsyncIter.count
- Defined in async/AsyncIter.ts:128

enumerate

enumerate(): AsyncEnumerate<B>
Returns AsyncEnumerate<B>
Inherited from AsyncIter.enumerate
- Defined in async/AsyncIter.ts:56

filter

filter<S>(fn: IAsyncFilterPredicateFn<B, S>): AsyncFilter<B, S>
Type Parameters
- S
Parameters
- fn: IAsyncFilterPredicateFn<B, S>
Returns AsyncFilter<B, S>
Inherited from AsyncIter.filter
- Defined in async/AsyncIter.ts:85
filter(fn: IAsyncFilterBooleanFn<B>): AsyncFilter<B, B>
Parameters
- fn: IAsyncFilterBooleanFn<B>
Returns AsyncFilter<B, B>
Inherited from AsyncIter.filter
- Defined in async/AsyncIter.ts:86

find

find(fn: ((value: B, index: number) => boolean)): Promise<Option<B>>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<Option<B>>
Inherited from AsyncIter.find
- Defined in async/AsyncIter.ts:183

findAll

findAll(fn: ((value: B) => boolean)): AsyncFilter<B, B>
Parameters
- fn: ((value: B) => boolean)
  - - (value: B): boolean
    - Parameters
      
      value: B
      
      Returns boolean
Returns AsyncFilter<B, B>
Inherited from AsyncIter.findAll
- Defined in async/AsyncIter.ts:198

findIndex

findIndex(fn: ((value: B, index: number) => boolean)): Promise<number>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<number>
Inherited from AsyncIter.findIndex
- Defined in async/AsyncIter.ts:168

first

first(): Promise<Option<B>>
Returns Promise<Option<B>>
Inherited from AsyncIter.first
- Defined in async/AsyncIter.ts:219

flatten

flatten<D>(depth?: D): AsyncFlatten<B, D>
Type Parameters
- D extends number = 1
Parameters
- Optional depth: D
Returns AsyncFlatten<B, D>
Inherited from AsyncIter.flatten
- Defined in async/AsyncIter.ts:114

forEach

forEach(fn: IAsyncForEachFn<B>): AsyncForEach<B>
Parameters
- fn: IAsyncForEachFn<B>
Returns AsyncForEach<B>
Inherited from AsyncIter.forEach
- Defined in async/AsyncIter.ts:66

indexOf

indexOf(value: B): Promise<number>
Parameters
- value: B
Returns Promise<number>
Inherited from AsyncIter.indexOf
- Defined in async/AsyncIter.ts:153

iter

iter(): AsyncIter<B>
Returns AsyncIter<B>
Inherited from AsyncIter.iter
- Defined in async/AsyncIter.ts:38

join

join(separator?: string): Promise<string>
Parameters
- Optional separator: string
Returns Promise<string>
Inherited from AsyncIter.join
- Defined in async/AsyncIter.ts:149

last

last(): Promise<Option<B>>
Returns Promise<Option<B>>
Inherited from AsyncIter.last
- Defined in async/AsyncIter.ts:223

map

map<B>(fn: IAsyncMapFn<B, B>): AsyncMap<B, B>
Type Parameters
- B
Parameters
- fn: IAsyncMapFn<B, B>
Returns AsyncMap<B, B>
Inherited from AsyncIter.map
- Defined in async/AsyncIter.ts:71

merge

merge(iter: AsyncIterator<B, any, undefined>): AsyncMerge<B>
Parameters
- iter: AsyncIterator<B, any, undefined>
Returns AsyncMerge<B>
Inherited from AsyncIter.merge
- Defined in async/AsyncIter.ts:76

next

next(): Promise<IteratorResult<B, undefined>>
Returns Promise<IteratorResult<B, undefined>>
Overrides AsyncIter.next
- Defined in async/AsyncMap.ts:13

nextWithIndex

nextWithIndex(): Promise<IteratorResult<[B, number], undefined>>
Returns Promise<IteratorResult<[B, number], undefined>>
Inherited from AsyncIter.nextWithIndex
- Defined in async/AsyncIter.ts:46

none

none(fn: ((value: B, index: number) => boolean)): Promise<boolean>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<boolean>
Inherited from AsyncIter.none
- Defined in async/AsyncIter.ts:245

nth

nth(index?: number): Promise<Option<B>>
Parameters
- index: number = 0
Returns Promise<Option<B>>
Inherited from AsyncIter.nth
- Defined in async/AsyncIter.ts:202

peekable

peekable(): AsyncPeekable<B>
Returns AsyncPeekable<B>
Inherited from AsyncIter.peekable
- Defined in async/AsyncIter.ts:61

reduce

reduce<C>(acc: C, fn: ((acc: C, value: B, index: number) => C)): Promise<C>
Type Parameters
- C
Parameters
- acc: C
- fn: ((acc: C, value: B, index: number) => C)
  - - (acc: C, value: B, index: number): C
    - Parameters
      
      acc: C
      
      value: B
      
      index: number
      
      Returns C
Returns Promise<C>
Inherited from AsyncIter.reduce
- Defined in async/AsyncIter.ts:264

reverse

reverse(): AsyncReverse<B>
Returns AsyncReverse<B>
Inherited from AsyncIter.reverse
- Defined in async/AsyncIter.ts:124

skip

skip(skip: number): AsyncSkip<B>
Parameters
- skip: number
Returns AsyncSkip<B>
Inherited from AsyncIter.skip
- Defined in async/AsyncIter.ts:96

some

some(fn: ((value: B, index: number) => boolean)): Promise<boolean>
Parameters
- fn: ((value: B, index: number) => boolean)
  - - (value: B, index: number): boolean
    - Parameters
      
      value: B
      
      index: number
      
      Returns boolean
Returns Promise<boolean>
Inherited from AsyncIter.some
- Defined in async/AsyncIter.ts:242

step

step(step: number): AsyncStep<B>
Parameters
- step: number
Returns AsyncStep<B>
Inherited from AsyncIter.step
- Defined in async/AsyncIter.ts:91

take

take(count: number): AsyncTake<B>
Parameters
- count: number
Returns AsyncTake<B>
Inherited from AsyncIter.take
- Defined in async/AsyncIter.ts:101

toArray

toArray(): Promise<B[]>
Returns Promise<B[]>
Inherited from AsyncIter.toArray
- Defined in async/AsyncIter.ts:142

toMap

toMap<K, V>(keyFn?: IToMapFn<B, K>, valueFn?: IToMapFn<B, V>): AsyncToMap<B, K, V>
Type Parameters
- K extends string | number | symbol
- V
Parameters
- Optional keyFn: IToMapFn<B, K>
- Optional valueFn: IToMapFn<B, V>
Returns AsyncToMap<B, K, V>
Inherited from AsyncIter.toMap
- Defined in async/AsyncIter.ts:106

unflatten

unflatten<U>(fn: IAsyncUnflattenFn<B, U>): AsyncUnflatten<B, U>
Type Parameters
- U
Parameters
- fn: IAsyncUnflattenFn<B, U>
Returns AsyncUnflatten<B, U>
Inherited from AsyncIter.unflatten
- Defined in async/AsyncIter.ts:119

Generated using TypeDoc