A library built for async iteration protocol.
npm install itiriri-asyncjavascript
import * as WebRequest from 'web-request';
import itiririAsync from 'itiriri-async';
type ToDo = {
id: number,
userId: number,
title: string,
completed: boolean,
};
async function* todosAsync() {
let id = 1;
while (true) {
yield await WebRequest.json( https://jsonplaceholder.typicode.com/todos/${id++});
}
}
async function showTop2ToDos(): Promise {
const todos = await itiririAsync(todosAsync())
.filter(x => !x.completed)
.take(2)
.awaitAll();
console.log(todos.toArray());
}
showTop2ToDos();
// [ 'delectus aut autem', 'quis ut nam facilis et officia qui' ]
`
> Check examples folder for more
Installation
Using npm:
`javascript
$ npm install 'itiriri-async' --save
`
Importing:
`javascript
import itiririAsync from 'itiriri-async';
`
Running tests
`javascript
$ npm install
$ npm test
`
---
Complete list of methods
* average
* awaitAll
* concat
* distinct
* entries
* every
* exclude
* filter
* find
* findIndex
* findLast
* findLastIndex
* first
* flat
* forEach
* groupJoin
* includes
* indexOf
* intersect
* join
* keys
* last
* lastIndexOf
* leftJoin
* length
* map
* max
* min
* nth
* prepend
* reduce
* skip
* slice
* some
* sum
* take
* union
* values
$3
Returns the average value.
> Syntax
`javascript
average(): Promise;
average(selector: (element: T, index: number) => number): Promise;
`
> Parameters
selector - (optional)* a value transformer function to apply to each element
For a sequence with no elements returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [41, 42, 43];
}
async function* generator2() {
yield* [{value: 1}, {value: 2}];
}
itiririAsync(generator1()).average() // returns Promise<42>
itiririAsync(generator2()).average(elem => elem.value) // returns Promise<1.5>
`
$3
Awaits for all elements an returns IterableQuery.
The ruterned iterable is a sync itiriri iterable.
> Syntax
`javascript
awaitAll(): Promise>
`
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [41, 40, 43];
}
// ...
const numbers = await itiririAsync(generator()).awaitAll();
// returns IterableQuery([41, 40, 43])
numbers.sort().toArray();
// returns: [40, 41, 43]
`
$3
Concatenates the sequence with another one.
> Syntax
`javascript
concat(other: T): AsyncIterableQuery;
concat(other: Promise): AsyncIterableQuery;
concat(other: Iterable): AsyncIterableQuery;
concat(other: AsyncIterable): AsyncIterableQuery;
`
> Parameters
other - (required)* sequence to concatenate
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [1, 2, 3];
}
async function* generator2() {
yield* [4, 5];
}
(async function() {
const q = await itiririAsync(generator1()).concat(generator2()).awaitAll();
q.toArray(); // returns [1, 2, 3, 4, 5]
})();
(async function() {
const q = await itiririAsync(generator1()).concat([2, 1]).awaitAll();
q.toArray(); // returns [1, 2, 3, 2, 1]
})();
(async function() {
const q = await itiririAsync(generator1()).concat(-1).awaitAll();
q.toArray(); // returns [1, 2, 3, -1]
})();
`
concat is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of unique elements.
> Syntax
`javascript
distinct(): AsyncIterableQuery;
distinct(selector: (element: T) => S): AsyncIterableQuery;
`
> Parameters
selector - (optional)* a value transformer function to be used for comparisons
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 3, 3, 4, 2];
}
(async function () {
const q = await itiririAsync(generator()).distinct().awaitAll();
q.toArray(); // returns [1, 2, 3, 4]
})();
`
distinct is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of key/value pair for each element and its index.
> Syntax
`javascript
entries(): AsyncIterableQuery<[number, T]>;
`
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* ['Bob', 'Alice'];
}
(async function () {
const q = await itiririAsync(generator()).entries().awaitAll();
q.toArray(); // returns [[0, 'Bob'], [1, 'Alice']]
})();
`
entries is a deferred method and is executed only when the result sequence is iterated.
$3
Tests whether all the elements pass the predicate.
> Syntax
`javascript
every(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 4, 3, 0];
}
(async function () {
await itiririAsync(generator()).every(x => x >= 0); // true
})();
(async function () {
await itiririAsync(generator()).every(x => x > 0); // false
})();
`
$3
Returns a sequence of elements not contained in a given sequence.
> Syntax
`javascript
exclude(others: Iterable): AsyncIterableQuery;
exclude(others: Iterable, selector: (element: T) => S): AsyncIterableQuery;
`
> Parameters
others - (required)* a sequence of elements to be excluded
selector - (optional)* a value transformer function to be used for comparisons
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [2, 0, 1, 8, 2];
}
async function* generator2() {
yield* [{ id: 1 }, { id: 2 }];
}
(async function () {
const q = await itiririAsync(generator1()).exclude([0, 1]).awaitAll();
q.toArray(); // returns [2, 8, 2]
})();
(async function () {
const q = await itiririAsync(generator2()).exclude([{ id: 2 }], x => x.id).awaitAll();
q.toArray(); // returns [{id: 1}]
})();
`
exclude is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of elements that pass the predicate.
> Syntax
`javascript
filter(predicate: (element: T, index: number) => boolean): AsyncIterableQuery;
`
> Parameters
predicate - (required)* function to test for each element
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 4, 5];
}
(async function () {
const q = await itiririAsync(generator()).filter(elem => elem < 3).awaitAll();
q.toArray(); // returns [1, 2]
})();
(async function () {
const q = await itiririAsync(generator()).filter(elem => elem > 10).awaitAll();
q.toArray(); // returns []
})();
`
filter is a deferred method and is executed only when the result sequence is iterated.
$3
Finds the first element that satisfies the specified predicate.
> Syntax
`javascript
find(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
If no element satisfies the predicate, returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 4, 5];
}
(async function () {
await itiririAsync(generator()).find(elem => elem > 2); // returns 3
})();
(async function () {
await itiririAsync(generator()).find(elem => elem > 10); // returns undefined
})();
`
$3
Finds the first index at which a given element satisfies the specified predicate.
> Syntax
`javascript
findIndex(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
If no element satisfies the predicate, returns -1.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 4, 5];
}
(async function () {
await itiririAsync(generator()).find(elem => elem > 2); // returns 2
})();
(async function () {
await itiririAsync(generator()).find(elem => elem > 10); // returns -1
})();
`
$3
Finds the last element that satisfies the specified predicate.
> Syntax
`javascript
findLast(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
If no element satisfies the predicate, returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 4, 5];
}
(async function () {
await itiririAsync(generator()).findLast(elem => elem > 2); // returns 5
})();
(async function () {
await itiririAsync(generator()).findLast(elem => elem > 10); // returns undefined
})();
`
$3
Finds the last index at which a given element satisfies the specified predicate.
> Syntax
`javascript
findLastIndex(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
If not present, returns -1.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 4, 5];
}
(async function () {
await itiririAsync(generator()).findLastIndex(elem => elem > 2); // returns 4
})();
(async function () {
await itiririAsync(generator()).findLastIndex(elem => elem > 10); // returns -1
})();
`
$3
Returns the first element in a sequence.
> Syntax
`javascript
first(): Promise;
`
For an empty sequence returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [1, 2, 3, 4, 5];
}
async function* generator2() {
yield* [];
}
(async function () {
await itiririAsync(generator1()).first(); // returns 1
})();
(async function () {
await itiririAsync(generator2()).first(); // returns undefined
})();
`
$3
Returns a sequence with all sub-sequences concatenated.
> Syntax
`javascript
flat(selector?: (element: T, index: number) => AsyncIterable): AsyncIterableQuery;
`
> Parameters
selector - (optional)* a value transformer function to be used for comparisons
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [[1, 2, 3], [4, 5]];
}
(async function () {
const q = await itiririAsync(generator()).flat().awaitAll();
q.toArray(); // returns [1, 2, 3, 4, 5]
})();
`
flat is a deferred method and is executed only when the result sequence is iterated.
$3
Runs through every element and applies a given function.
> Syntax
`javascript
forEach(action: (element: T, index: number) => void): Promise;
`
> Parameters
action - (required)* function to apply on each element
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
await itiririAsync(generator()).forEach(elem => console.log(elem));
})();
// 1
// 2
// 3
`
$3
Returns a sequence of correlated elements where each element from the current sequence
is matched with zero or more elements from the other sequence.
> Syntax
`javascript
groupJoin(
other: Iterable,
leftKeySelector: (element: T, index: number) => TKey,
rightKeySelector: (element: TRight, index: number) => TKey,
joinSelector: (left: T, right: TRight[]) => TResult,
): AsyncIterableQuery;
`
> Parameters
other - (required)* sequence to join
leftKeySelector - (required)* function that provides the key of each element from source sequence
rightKeySelector - (required)* function that provides the key of each element from joined sequence
joinSelector - (required)* a transformation function to apply on each joined element with group
The joinSelector function is called on each element from the source sequence and the array of matched
elements from the joined sequence.
When an element from the source sequence doesn't match with any of the elements from the joined sequence,
the joinSelector function will be called with an empty array.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator())
.groupJoin([1, 2, 3, 1, 1, 2], x => x, x => x, (x, y) => ({ x, y }))
.awaitAll();
q.toArray();
})();
//[ { x: 1, y: [ 1, 1, 1 ] },
// { x: 2, y: [ 2, 2 ] },
// { x: 3, y: [ 3 ] } ]
`
groupJoin is a deferred method and is executed only when the result sequence is iterated.
$3
Determines whether the sequence includes a certain element.
> Syntax
`javascript
includes(element: T): Promise;
includes(element: T, fromIndex: number): Promise;
`
> Parameters
element - (required)* the element to search for
fromIndex - (optional)* starting index, defaults to 0
includes uses triple equals === to compare elements.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
await itiririAsync(generator()).includes(2); // returns: true
await itiririAsync(generator()).includes(4); // returns: false
})();
`
$3
Returns the first (zero-based) index at which a given element can be found.
> Syntax
`javascript
indexOf(element: T): Promise;
indexOf(element: T, fromIndex: number): Promise;
`
> Parameters
element - (required)* the element to search for
fromIndex - (optional)* starting index, defaults to 0
When an element is not found, returns -1.
indexOf uses triple equals === to compare elements.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
await itiririAsync(generator()).indexOf(2); // returns: 1
await itiririAsync(generator()).indexOf(4); // returns: -1
})();
`
$3
Returns a set intersection with a given sequence.
> Syntax
`javascript
intersect(others: Iterable): AsyncIterableQuery;
intersect(other: Iterable, selector: (element: T) => S): AsyncIterableQuery;
`
> Parameters
other - (required)* the sequence to intersect with
selector - (optional)* a value transformer function to be used for comparisons
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator())
.intersect([1, 2, 4])
.awaitAll();
q.toArray(); // returns: [1, 2]
})();
`
intersect is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of correlated elements transformation that match a given key.
> Syntax
`javascript
join(
other: Iterable,
leftKeySelector: (element: T, index: number) => TKey,
rightKeySelector: (element: TRight, index: number) => TKey,
joinSelector: (left: T, right: TRight) => TResult,
): AsyncIterableQuery;
`
> Parameters
other - (required)* sequence to join
leftKeySelector - (required)* function that provides the key of each element from source sequence
rightKeySelector - (required)* function that provides the key of each element from joined sequence
joinSelector - (required)* a transformation function to apply on each matched tuple
The join method works as an sql inner join.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator())
.join([1, 1, 2], x => x, x => x, (x, y) => ({ x, y }))
.awaitAll();
q.toArray(); // returns: [ { x: 1, y: 1 }, { x: 1, y: 1 }, { x: 2, y: 2 } ]
})();
`
join is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of keys for each index in the source sequence.
> Syntax
`javascript
keys(): AsyncIterableQuery;
`
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* ['a', 'b', 'c'];
}
(async function () {
const q = await itiririAsync(generator()).keys().awaitAll();
q.toArray(); // returns: [0, 1, 2]
})();
`
keys is a deferred method and is executed only when the result sequence is iterated.
$3
Returns the last element in a sequence.
> Syntax
`javascript
last(): Promise;
`
For an empty sequence returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, -2];
}
(async function () {
await itiririAsync(generator()).last(); // returns: -2
})();
`
$3
Returns the last index at which a given element can be found.
> Syntax
`javascript
lastIndexOf(element: T): Promise;
lastIndexOf(element: T, fromIndex: number): Promise;
`
> Parameters
element - (required)* the element to search for
fromIndex - (optional)* starting index, defaults to 0
When an element is not found, returns -1.
lastIndexOf uses triple equals === to compare elements.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 2, 1];
}
(async function () {
await itiririAsync(generator()).lastIndexOf(2); // returns: 3
})();
`
$3
Returns a sequence of correlated elements transformation that match a given key.
> Syntax
`javascript
leftJoin(
other: Iterable,
leftKeySelector: (element: T, index: number) => TKey,
rightKeySelector: (element: TRight, index: number) => TKey,
joinSelector: (left: T, right?: TRight) => TResult,
): AsyncIterableQuery;
`
> Parameters
other - (required)* sequence to join
leftKeySelector - (required)* function that provides the key of each element from source sequence
rightKeySelector - (required)* function that provides the key of each element from joined sequence
joinSelector - (required)* a transformation function to apply on each matched tuple
The leftJoin method works as an sql left join.
When an element from the left sequence doesn't match with any of the elements from the right sequence,
the joinSelector function is called with an undefined right value.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator())
.leftJoin([2, 3, 4, 2], n => n, n => n, (a, b) => ${a}-${b || '#'})
.awaitAll();
q.toArray(); // returns ['1-#', '2-2', '2-2', '3-3']
})();
`
leftJoin is a deferred method and is executed only when the result sequence is iterated.
$3
Returns the number of elements in a sequence.
> Syntax
`javascript
length(): Promise;
length(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (optional)* a function to count only the elements that match the predicate
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
await itiririAsync(generator()).length(); // returns 3
})();
`
$3
Returns a sequence of transformed values.
> Syntax
`javascript
map(selector: (element: T, index: number) => S): AsyncIterableQuery;
`
> Parameters
selector - (required)* a value transformer function to apply to each element
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
function x10(numbers: AsyncIterable) {
return itiririAsync(numbers).map(n => n * 10);
}
(async function(){
const numbers = await x10(generator()).awaitAll();
console.log(numbers); // [10, 20, 30]
})();
`
map is a deferred method and is executed only when the result sequence is iterated.
$3
Returns the maximum element in a sequence.
> Syntax
`javascript
max(): Promise;
max(compareFn: (a: T, b: T) => number): Promise;
`
> Parameters
compareFn - (optional)* a comparer function that compares two elements from a sequence and returns:
* -1 when a is less than b
* 1 when a is greater b
* 0 when a equals to b
If sequence is empty, returns undefined.
> Example
`javascript
async function* generator1() {
yield* [1, 42, 3];
}
async function* generator2() {
yield* [];
}
(async function () {
await itiririAsync(generator1()).max(); // returns 42
await itiririAsync(generator2()).max(); // returns undefined
})();
`
$3
Returns the minimum element in a sequence.
> Syntax
`javascript
min(): Promise;
min(compareFn: (a: T, b: T) => number): Promise;
`
> Parameters
compareFn - (optional)* a comparer function that compares two elements from a sequence and returns:
* -1 when a is less than b
* 1 when a is greater b
* 0 when a equals to b
If sequence is empty, returns undefined.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [1, -2, 3];
}
async function* generator2() {
yield* [];
}
(async function () {
await itiririAsync(generator1()).min(); // returns -1
await itiririAsync(generator2()).min(); // returns undefined
})();
`
$3
Returns the element at a specified index.
> Syntax
`javascript
nth(index: number): Promise;
`
> Parameters
index - (required)* zero based index at which to get the element
If index is out of the range, returns undefined .
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, -2, 3];
}
(async function () {
await itiririAsync(generator()).nth(2); // returns: 3
await itiririAsync(generator()).nth(3); // returns: undefined
})();
`
$3
Returns a sequence with given elements at the beginning.
> Syntax
`javascript
prepend(other: T): AsyncIterableQuery;
prepend(other: Promise): AsyncIterableQuery;
prepend(other: Iterable): AsyncIterableQuery;
prepend(other: AsyncIterable): AsyncIterableQuery;
`
> Parameters
other - (required)* the sequence to be added at the beginning
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, -2, 3];
}
(async function () {
const q = await itiririAsync(generator()).prepend(4).awaitAll();
q.toArray(); // returns: [4, 1, -2, 3]
})();
(async function () {
const q = await itiririAsync(generator()).prepend([0, 4]).awaitAll();
q.toArray(); // returns: [0, 4, 1, -2, 3]
})();
`
prepend is a deferred method and is executed only when the result sequence is iterated.
$3
Applies a function against an accumulator and each element (from left to right) to reduce it to a single value.
> Syntax
`javascript
reduce(
callback: (accumulator: T, current: T, index: number) => T,
): Promise;
reduce(
callback: (accumulator: S, current: T, index: number) => S,
initialValue: S,
): Promise;
`
> Parameters
callback - (required)* function to execute on each element in the sequence, taking three arguments
* accumulator the accumulator accumulates the callback's return values;
* current the current element being processed;
* currentIndex the index of the current element being processed;
initialValue - (optional)* value to use as the first argument to the first call of the callback
Calling reduce on an empty sequence without an initial value throws an error.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
// 5 + 10 + 20 + 30
await itiririAsync(generator()).reduce((accum, elem) => accum + elem * 10, 5); // returns 65
})();
`
$3
Skips the specified number of elements from the beginning of sequence and returns the remaining ones.
> Syntax
`javascript
skip(count: number): AsyncIterableQuery;
`
> Parameters
count - (required)* number of elements to skip
When count is greater than actual number of elements, results in an empty sequence.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator()).skip(1).awaitAll();
q.toArray(); // returns: [2, 3]
})();
(async function () {
const q = await itiririAsync(generator()).skip(10).awaitAll();
q.toArray(); // returns: []
})();
`
skip is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence that represents the range of elements from start to end.
> Syntax
`javascript
slice(start: number, end: number): AsyncIterableQuery;
`
> Parameters
start - (required)* zero-based index at which to begin extraction
end - (required)* zero-based index before which to end extraction.
The end index is not included in the result.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, 3, 4];
}
(async function () {
const q = await itiririAsync(generator()).slice(2, 4).awaitAll();
q.toArray(); // returns: [3, 3]
})();
`
slice is a deferred method and is executed only when the result sequence is iterated.
$3
Tests whether at least one element passes the predicate.
> Syntax
`javascript
some(predicate: (element: T, index: number) => boolean): Promise;
`
> Parameters
predicate - (required)* function to test for each element
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3, -3, 4, 0];
}
(async function () {
await itiririAsync(generator()).some(x => x < 0); // returns: true
await itiririAsync(generator()).some(x => x > 5); // returns: false
})();
`
$3
Returns the sum of all elements.
> Syntax
`javascript
sum(): number;
sum(selector: (element: T, index: number) => number): Promise;
`
> Parameters
selector - (optional)* a value transformer function to apply to each element
Optionally, a function can be provided to apply a transformation and map each element to a value.
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [1, 2, 3];
}
async function* generator2() {
yield* [{ val: 3 }, { val: 5 }];
}
(async function () {
await itiririAsync(generator1()).sum(); // returns: 6
await itiririAsync(generator2()).sum(x => x.val); // returns: 8
})();
`
$3
Returns a specified number of elements from the beginning of sequence.
> Syntax
`javascript
take(count: number): AsyncIterableQuery;
`
> Parameters
count - (required)* number of elements to take
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 2, 3];
}
(async function () {
const q = await itiririAsync(generator()).take(2).awaitAll();
q.toArray(); // returns: [1, 2]
})();
(async function () {
const q = await itiririAsync(generator()).take(0).awaitAll();
q.toArray(); // returns: []
})();
`
take is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a set union with a given sequence.
> Syntax
`javascript
union(other: AsyncIterable): AsyncIterableQuery;
union(other: AsyncIterable, selector: (element: T) => S): AsyncIterableQuery;
`
> Parameters
other - (required)* the sequence to join with
selector - (optional)* a value transformer function to be used for comparisons
Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator1() {
yield* [1, 2, 3];
}
async function* generator2() {
yield* [3, 4, 5];
}
(async function () {
const q = await itiririAsync(generator1()).union(generator2()).awaitAll();
q.toArray(); // returns [1, 2, 3, 4, 5]
})();
`
union is a deferred method and is executed only when the result sequence is iterated.
$3
Returns a sequence of values for each index in the source sequence.
> Syntax
`javascript
values(): AsyncIterableQuery;
`
> Example
`javascript
import itiririAsync from 'itiriri-async';
async function* generator() {
yield* [1, 0, 2, 3];
}
(async function () {
const q = await itiririAsync(generator()).values().awaitAll();
q.toArray(); // [1, 0, 2, 3]
})();
`
values` is a deferred method and is executed only when the result sequence is iterated.