CbFlu | Sugar.js - v2.12.0-beta.4

Type parameters

A: unknown[]
T = A[0]
This = never

Hierarchy

Flu<T>
- CbFlu

Index

Properties

Readonly iter

iter: () => AsyncIterable<T>

Type declaration

- (): AsyncIterable<T>
- Returns AsyncIterable<T>

Readonly isEnd

isEnd: boolean

Methods

[asyncIterator]

[asyncIterator](): AsyncIterator<T, any, undefined>

Inherited from Flu.[asyncIterator]
- Defined in flu.ts:12
Returns AsyncIterator<T, any, undefined>

Static empty

empty<T>(): Flu<T>

Inherited from Flu.empty
- Defined in flu.ts:16
Type parameters
- T
Returns Flu<T>

Static by

by<T>(iter: () => AsyncIterable<T>): Flu<T>

Inherited from Flu.by
- Defined in flu.ts:20
Type parameters
- T
Parameters
- iter: () => AsyncIterable<T>
 - - (): AsyncIterable<T>
 - Returns AsyncIterable<T>
Returns Flu<T>

Static of

of<T>(...iter: T[]): Flu<T>

Inherited from Flu.of
- Defined in flu.ts:24
Type parameters
- T
Parameters
- Rest ...iter: T[]
Returns Flu<T>

Static from

from<T>(iter: Iterable<T>): Flu<T>

Inherited from Flu.from
- Defined in flu.ts:28
Type parameters
- T
Parameters
- iter: Iterable<T>
Returns Flu<T>

Static fromIter

fromIter<T>(iter: Iterable<T | Promise<T>>): Flu<T>

Inherited from Flu.fromIter
- Defined in flu.ts:32
Type parameters
- T
Parameters
- iter: Iterable<T | Promise<T>>
Returns Flu<T>

Static fromCallback

fromCallback<T>(): CbFlu<[T], T, never>
fromCallback<A, T, This>(map?: (...args: A) => T): CbFlu<A, T, This>

Inherited from Flu.fromCallback
- Defined in flu.ts:36
Type parameters
- T
Returns CbFlu<[T], T, never>
Inherited from Flu.fromCallback
- Defined in flu.ts:37
Type parameters
- A: unknown[]
- T = A[0]
- This = never
Parameters
- Optional map: (...args: A) => T
 - - (...args: A): T
 - Parameters
 - Rest ...args: A
 Returns T
Returns CbFlu<A, T, This>

Static to

to(to: number, step?: number): Flu<number>

Inherited from Flu.to
- Defined in flu.ts:43
Create a Flu from a range starting from 0

Parameters
- to: number
- step: number = 1
Returns Flu<number>

Static range

range(from: number, to: number, step?: number): Flu<number>

Inherited from Flu.range
- Defined in flu.ts:54
Create a Flu from a range

Parameters
- from: number
- to: number
- step: number = 1
Returns Flu<number>

collect

collect(): Promise<T[]>

Inherited from Flu.collect
- Defined in flu.ts:65
Returns Promise<T[]>

join

join(separator?: string): Promise<string>

Inherited from Flu.join
- Defined in flu.ts:69
Parameters
- Optional separator: string
Returns Promise<string>

count

count(): Promise<number>

Inherited from Flu.count
- Defined in flu.ts:73
Returns Promise<number>

isEmpty

isEmpty(): Promise<boolean>

Inherited from Flu.isEmpty
- Defined in flu.ts:77
Returns Promise<boolean>

first

first(): Promise<Voidable<T>>

Inherited from Flu.first
- Defined in flu.ts:81
Returns Promise<Voidable<T>>

firstO

firstO(): Promise<Option<T>>

Inherited from Flu.firstO
- Defined in flu.ts:85
Returns Promise<Option<T>>

last

last(): Promise<Voidable<T>>

Inherited from Flu.last
- Defined in flu.ts:89
Returns Promise<Voidable<T>>

lastO

lastO(): Promise<Option<T>>

Inherited from Flu.lastO
- Defined in flu.ts:93
Returns Promise<Option<T>>

nth

nth(n: number): Promise<Voidable<T>>

Inherited from Flu.nth
- Defined in flu.ts:97
Parameters
- n: number
Returns Promise<Voidable<T>>

nthO

nthO(n: number): Promise<Option<T>>

Inherited from Flu.nthO
- Defined in flu.ts:101
Parameters
- n: number
Returns Promise<Option<T>>

stepBy

stepBy(step: number): Flu<T>

Inherited from Flu.stepBy
- Defined in flu.ts:105
Parameters
- step: number
Returns Flu<T>

chain

chain(other: AsyncIterable<T> | Iterable<T>, ...more: (AsyncIterable<T> | Iterable<T>)[]): Flu<T>

Inherited from Flu.chain
- Defined in flu.ts:109
Parameters
- other: AsyncIterable<T> | Iterable<T>
- Rest ...more: (AsyncIterable<T> | Iterable<T>)[]
Returns Flu<T>

zip

zip(other: AsyncIterable): Flu<[T, U]>

Inherited from Flu.zip
- Defined in flu.ts:113
Type parameters
- U
Parameters
- other: AsyncIterable
Returns Flu<[T, U]>

unzip

unzip(): Promise<[(T extends [A, any] | readonly [A, any] ? A : T extends R[] ? R : unknown)[], (T extends [any, B] | readonly [any, B] ? B : T extends R[] ? R : unknown)[]]>

Inherited from Flu.unzip
- Defined in flu.ts:117
Returns Promise<[(T extends [A, any] | readonly [A, any] ? A : T extends R[] ? R : unknown)[], (T extends [any, B] | readonly [any, B] ? B : T extends R[] ? R : unknown)[]]>

map

map<R>(f: (v: T) => R): Flu<R>

Inherited from Flu.map
- Defined in flu.ts:124
Type parameters
- R
Parameters
- f: (v: T) => R
 - - (v: T): R
 - Parameters
 - v: T
 Returns R
Returns Flu<R>

mapWait

mapWait<R>(f: (v: T) => R | PromiseLike<R>): Flu<R>

Inherited from Flu.mapWait
- Defined in flu.ts:128
Type parameters
- R
Parameters
- f: (v: T) => R | PromiseLike<R>
 - - (v: T): R | PromiseLike<R>
 - Parameters
 - v: T
 Returns R | PromiseLike<R>
Returns Flu<R>

fill

fill<R>(v: R): Flu<R>

Inherited from Flu.fill
- Defined in flu.ts:132
Type parameters
- R
Parameters
- v: R
Returns Flu<R>

forEach

forEach(f: (v: T) => unknown): Promise<void>

Inherited from Flu.forEach
- Defined in flu.ts:136
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Promise<void>

run

run(): Promise<void>

Inherited from Flu.run
- Defined in flu.ts:140
Returns Promise<void>

filter

filter<S>(f: (v: T) => v is S): Flu<S>
filter(f: (v: T) => unknown): Flu<T>

Inherited from Flu.filter
- Defined in flu.ts:144
Type parameters
- S
Parameters
- f: (v: T) => v is S
 - - (v: T): v is S
 - Parameters
 - v: T
 Returns v is S
Returns Flu<S>
Inherited from Flu.filter
- Defined in flu.ts:145
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

enumerate

enumerate(): Flu<[T, number]>

Inherited from Flu.enumerate
- Defined in flu.ts:150
Returns Flu<[T, number]>

indexed

indexed(): Flu<[number, T]>

Inherited from Flu.indexed
- Defined in flu.ts:154
Returns Flu<[number, T]>

skip

skip(n: number): Flu<T>

Inherited from Flu.skip
- Defined in flu.ts:158
Parameters
- n: number
Returns Flu<T>

take

take(n: number): Flu<T>

Inherited from Flu.take
- Defined in flu.ts:162
Parameters
- n: number
Returns Flu<T>

slice

slice(from: number, to: number): Flu<T>

Inherited from Flu.slice
- Defined in flu.ts:166
Parameters
- from: number
- to: number
Returns Flu<T>

sub

sub(from: number, count: number): Flu<T>

Inherited from Flu.sub
- Defined in flu.ts:170
Parameters
- from: number
- count: number
Returns Flu<T>

scan

scan<R>(init: R, f: (acc: R, val: T) => R): Flu<R>

Inherited from Flu.scan
- Defined in flu.ts:174
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
 - - (acc: R, val: T): R
 - Parameters
 - acc: R
 - val: T
 Returns R
Returns Flu<R>

scanWait

scanWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Flu<R>

Inherited from Flu.scanWait
- Defined in flu.ts:178
Type parameters
- R
Parameters
- init: R | PromiseLike<R>
- f: (acc: R, val: T) => R | PromiseLike<R>
 - - (acc: R, val: T): R | PromiseLike<R>
 - Parameters
 - acc: R
 - val: T
 Returns R | PromiseLike<R>
Returns Flu<R>

flatMap

flatMap<R>(f: (v: T) => AsyncIterable<R> | Iterable<R>): Flu<R>

Inherited from Flu.flatMap
- Defined in flu.ts:182
Type parameters
- R
Parameters
- f: (v: T) => AsyncIterable<R> | Iterable<R>
 - - (v: T): AsyncIterable<R> | Iterable<R>
 - Parameters
 - v: T
 Returns AsyncIterable<R> | Iterable<R>
Returns Flu<R>

flatten

flatten(): T extends AsyncIterable<R> ? Flu<R> : T extends Iterable<R> ? Flu<R> : never

Inherited from Flu.flatten
- Defined in flu.ts:186
Returns T extends AsyncIterable<R> ? Flu<R> : T extends Iterable<R> ? Flu<R> : never

wait

wait(): T extends R | PromiseLike<R> ? Flu<R> : never

Inherited from Flu.wait
- Defined in flu.ts:190
Returns T extends R | PromiseLike<R> ? Flu<R> : never

also

also(f: (v: T) => unknown): Flu<T>

Inherited from Flu.also
- Defined in flu.ts:194
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

fold

fold<R>(init: R, f: (acc: R, val: T) => R): Promise<R>

Inherited from Flu.fold
- Defined in flu.ts:198
Type parameters
- R
Parameters
- init: R
- f: (acc: R, val: T) => R
 - - (acc: R, val: T): R
 - Parameters
 - acc: R
 - val: T
 Returns R
Returns Promise<R>

foldWait

foldWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Promise<R>

Inherited from Flu.foldWait
- Defined in flu.ts:202
Type parameters
- R
Parameters
- init: R | PromiseLike<R>
- f: (acc: R, val: T) => R | PromiseLike<R>
 - - (acc: R, val: T): R | PromiseLike<R>
 - Parameters
 - acc: R
 - val: T
 Returns R | PromiseLike<R>
Returns Promise<R>

reduce

reduce(f: (acc: T, val: T) => T): Promise<T>

Inherited from Flu.reduce
- Defined in flu.ts:206
Parameters
- f: (acc: T, val: T) => T
 - - (acc: T, val: T): T
 - Parameters
 - acc: T
 - val: T
 Returns T
Returns Promise<T>

reduceWait

reduceWait(f: (acc: T, val: T) => T | PromiseLike<T>): Promise<T>

Inherited from Flu.reduceWait
- Defined in flu.ts:210
Parameters
- f: (acc: T, val: T) => T | PromiseLike<T>
 - - (acc: T, val: T): T | PromiseLike<T>
 - Parameters
 - acc: T
 - val: T
 Returns T | PromiseLike<T>
Returns Promise<T>

all

all(f: (v: T) => unknown): Promise<boolean>

Inherited from Flu.all
- Defined in flu.ts:214
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Promise<boolean>

any

any(f: (v: T) => unknown): Promise<boolean>

Inherited from Flu.any
- Defined in flu.ts:218
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Promise<boolean>

find

find(f: (v: T) => unknown): Promise<Voidable<T>>

Inherited from Flu.find
- Defined in flu.ts:222
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Promise<Voidable<T>>

position

position(f: (v: T) => unknown): Promise<number>

Inherited from Flu.position
- Defined in flu.ts:226
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Promise<number>

indexOf

indexOf(v: T): Promise<number>

Inherited from Flu.indexOf
- Defined in flu.ts:230
Parameters
- v: T
Returns Promise<number>

indexOfWait

indexOfWait(v: T | PromiseLike<T>): Promise<number>

Inherited from Flu.indexOfWait
- Defined in flu.ts:234
Parameters
- v: T | PromiseLike<T>
Returns Promise<number>

max

max(): Promise<Voidable<T>>

Inherited from Flu.max
- Defined in flu.ts:238
Returns Promise<Voidable<T>>

min

min(): Promise<Voidable<T>>

Inherited from Flu.min
- Defined in flu.ts:242
Returns Promise<Voidable<T>>

merge

merge(other: AsyncIterable): Flu<T | U>

Inherited from Flu.merge
- Defined in flu.ts:246
Type parameters
- U
Parameters
- other: AsyncIterable
Returns Flu<T | U>

delay

delay(ms?: Voidable<number>): Flu<T>
delay(f: (v: T) => unknown): Flu<T>
delay(ms: Voidable<number>, f: (v: T) => unknown): Flu<T>

Inherited from Flu.delay
- Defined in flu.ts:250
Parameters
- Optional ms: Voidable<number>
Returns Flu<T>
Inherited from Flu.delay
- Defined in flu.ts:251
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>
Inherited from Flu.delay
- Defined in flu.ts:252
Parameters
- ms: Voidable<number>
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

retry

retry(count: number): Flu<T>
retry<E>(f: (err: E, count: number) => unknown): Flu<T>
retry<E>(cond: number | ((err: E, count: number) => unknown)): Flu<T>

Inherited from Flu.retry
- Defined in flu.ts:258
Parameters
- count: number
Returns Flu<T>
Inherited from Flu.retry
- Defined in flu.ts:259
Type parameters
- E = unknown
Parameters
- f: (err: E, count: number) => unknown
 - - (err: E, count: number): unknown
 - Parameters
 - err: E
 - count: number
 Returns unknown
Returns Flu<T>
Inherited from Flu.retry
- Defined in flu.ts:260
Type parameters
- E = unknown
Parameters
- cond: number | ((err: E, count: number) => unknown)
Returns Flu<T>

timestamp

timestamp(): Flu<[value: T, timestamp: number]>

Inherited from Flu.timestamp
- Defined in flu.ts:265
Returns Flu<[value: T, timestamp: number]>

throttle

throttle(ms: number): Flu<T>

Inherited from Flu.throttle
- Defined in flu.ts:269
Parameters
- ms: number
Returns Flu<T>

debounce

debounce(ms: number): Flu<T>

Inherited from Flu.debounce
- Defined in flu.ts:273
Parameters
- ms: number
Returns Flu<T>

audit

audit(ms: number): Flu<T>

Inherited from Flu.audit
- Defined in flu.ts:277
Parameters
- ms: number
Returns Flu<T>

buffer

buffer(n: number, mode?: "count" | "time"): Flu<T[]>

Inherited from Flu.buffer
- Defined in flu.ts:281
Parameters
- n: number
- mode: "count" | "time" = 'count'
Returns Flu<T[]>

break

break(): Flu<T>

Inherited from Flu.break
- Defined in flu.ts:285
Returns Flu<T>

breakBy

breakBy(f: (v: T) => unknown): Flu<T>

Inherited from Flu.breakBy
- Defined in flu.ts:289
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

takeIf

takeIf(f: (v: T) => unknown): Flu<T>

Inherited from Flu.takeIf
- Defined in flu.ts:293
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

startBy

startBy(f: (v: T) => unknown): Flu<T>

Inherited from Flu.startBy
- Defined in flu.ts:297
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

skipIf

skipIf(f: (v: T) => unknown): Flu<T>

Inherited from Flu.skipIf
- Defined in flu.ts:301
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>

drop

drop(): Flu<void>

Inherited from Flu.drop
- Defined in flu.ts:305
Returns Flu<void>

forEnd

forEnd(): Flu<any>

Inherited from Flu.forEnd
- Defined in flu.ts:309
Returns Flu<any>

breakAt

breakAt(f: (v: T) => unknown): Flu<T>
breakAt(single: PromiseLike<unknown>): Flu<T>
breakAt(single: AsyncIterable<unknown>): Flu<T>
breakAt(single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)): Flu<T>

Inherited from Flu.breakAt
- Defined in flu.ts:313
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>
Inherited from Flu.breakAt
- Defined in flu.ts:314
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
Inherited from Flu.breakAt
- Defined in flu.ts:315
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
Inherited from Flu.breakAt
- Defined in flu.ts:316
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)
Returns Flu<T>

takeUntil

takeUntil(single: PromiseLike<unknown>): Flu<T>
takeUntil(single: AsyncIterable<unknown>): Flu<T>
takeUntil(single: PromiseLike<unknown> | AsyncIterable<unknown>): Flu<T>

Inherited from Flu.takeUntil
- Defined in flu.ts:322
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
Inherited from Flu.takeUntil
- Defined in flu.ts:323
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
Inherited from Flu.takeUntil
- Defined in flu.ts:324
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown>
Returns Flu<T>

startAt

startAt(f: (v: T) => unknown): Flu<T>
startAt(single: PromiseLike<unknown>): Flu<T>
startAt(single: AsyncIterable<unknown>): Flu<T>
startAt(single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)): Flu<T>

Inherited from Flu.startAt
- Defined in flu.ts:329
Parameters
- f: (v: T) => unknown
 - - (v: T): unknown
 - Parameters
 - v: T
 Returns unknown
Returns Flu<T>
Inherited from Flu.startAt
- Defined in flu.ts:330
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
Inherited from Flu.startAt
- Defined in flu.ts:331
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
Inherited from Flu.startAt
- Defined in flu.ts:332
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown> | ((v: T) => unknown)
Returns Flu<T>

skipUntil

skipUntil(single: PromiseLike<unknown>): Flu<T>
skipUntil(single: AsyncIterable<unknown>): Flu<T>
skipUntil(single: PromiseLike<unknown> | AsyncIterable<unknown>): Flu<T>

Inherited from Flu.skipUntil
- Defined in flu.ts:338
Parameters
- single: PromiseLike<unknown>
Returns Flu<T>
Inherited from Flu.skipUntil
- Defined in flu.ts:339
Parameters
- single: AsyncIterable<unknown>
Returns Flu<T>
Inherited from Flu.skipUntil
- Defined in flu.ts:340
Parameters
- single: PromiseLike<unknown> | AsyncIterable<unknown>
Returns Flu<T>

push

push(...items: T[]): Flu<T>

Inherited from Flu.push
- Defined in flu.ts:345
Parameters
- Rest ...items: T[]
Returns Flu<T>

unshift

unshift(...items: T[]): Flu<T>

Inherited from Flu.unshift
- Defined in flu.ts:349
Parameters
- Rest ...items: T[]
Returns Flu<T>

as

as(): Flu

Inherited from Flu.as
- Defined in flu.ts:353
Type parameters
- U
Returns Flu

groupBy

groupBy<K>(keyf: (v: T) => K): Flu<[K, T[]]>
groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): Flu<[K, V[]]>

Inherited from Flu.groupBy
- Defined in flu.ts:357
Type parameters
- K
Parameters
- keyf: (v: T) => K
 - - (v: T): K
 - Parameters
 - v: T
 Returns K
Returns Flu<[K, T[]]>
Inherited from Flu.groupBy
- Defined in flu.ts:358
Type parameters
- K
- V
Parameters
- keyf: (v: T) => K
 - - (v: T): K
 - Parameters
 - v: T
 Returns K
- valf: (v: T) => V
 - - (v: T): V
 - Parameters
 - v: T
 Returns V
Returns Flu<[K, V[]]>

toArray

toArray(): Promise<T[]>

Inherited from Flu.toArray
- Defined in flu.ts:363
Returns Promise<T[]>

toSet

toSet(): Promise<Set<T>>

Inherited from Flu.toSet
- Defined in flu.ts:367
Returns Promise<Set<T>>

toMap

toMap(): Promise<T extends [K, V] ? Map<K, V> : never>

Inherited from Flu.toMap
- Defined in flu.ts:371
Returns Promise<T extends [K, V] ? Map<K, V> : never>

cb

cb(...arg: A): void

- Defined in flu.ts:377
Parameters
- Rest ...arg: A
Returns void

end

end(): void

- Defined in flu.ts:378
Returns void

Constructors

constructor

new CbFlu<A, T, This>(map?: (...args: A) => T): CbFlu<A, T, This>

Inherited from Flu.constructor
- Defined in flu.ts:382
Type parameters
- A: unknown[]
- T = A[0]
- This = never
Parameters
- Optional map: (...args: A) => T
 - - (...args: A): T
 - Parameters
 - Rest ...args: A
 Returns T
Returns CbFlu<A, T, This>

Type parameters

A: unknown[]

T = A[0]

This = never

Hierarchy

Index

Properties

Methods

Constructors

Properties

Readonly iter

Type declaration

Returns AsyncIterable<T>

Readonly isEnd

Methods

[asyncIterator]

Returns AsyncIterator<T, any, undefined>

Static empty

Type parameters

T

Returns Flu<T>

Static by

Type parameters

T

Parameters

iter: () => AsyncIterable<T>

Returns AsyncIterable<T>

Returns Flu<T>

Static of

Type parameters

T

Parameters

Rest ...iter: T[]

Returns Flu<T>

Static from

Type parameters

T

Parameters

iter: Iterable<T>

Returns Flu<T>

Static fromIter

Type parameters

T

Parameters

iter: Iterable<T | Promise<T>>

Returns Flu<T>

Static fromCallback

Type parameters

T

Returns CbFlu<[T], T, never>

Type parameters

A: unknown[]

T = A[0]

This = never

Parameters

Optional map: (...args: A) => T

Parameters

Rest ...args: A

Returns T

Returns CbFlu<A, T, This>

Static to

Parameters

to: number

step: number = 1

Returns Flu<number>

Static range

Parameters

from: number

to: number

step: number = 1

Returns Flu<number>

collect

Returns Promise<T[]>

join

Parameters

Optional separator: string

Returns Promise<string>

count

Returns Promise<number>

isEmpty