Class AsyncIterableCollection<TInput>

All methods that return IAsyncCollection are executed lazly, meaning the execution will occur iterating the items withthe forEach method or for await loop.

IMPORT_PATH: "@daiso-tech/core/collection"

Type Parameters

TInput = unknown

Implements

IAsyncCollection<TInput>

Constructors

constructor

new AsyncIterableCollection<TInput = unknown>(
iterable?: AsyncIterableValue<TInput>,
settings?: AsyncIterableCollectionSettings,
): AsyncIterableCollection<TInput>

The constructor takes an Iterable | Iterable or AsyncIterable | AsyncIterable.

Works with Array.

Type Parameters

TInput = unknown

Parameters

iterable: AsyncIterableValue<TInput> = []
settings: AsyncIterableCollectionSettings = {}

Returns AsyncIterableCollection<TInput>

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = new AsyncIterableCollection([1, 2, 3, 4]);

Works with String.

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = new AsyncIterableCollection("ABCDE");

Works with Set.

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = new AsyncIterableCollection(new Set([1, 2, 2 4]));

Works with Map.

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = new AsyncIterableCollection(new Map([["a", 1], ["b", 2]]));

Works with any Iterable.

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

class MyIterable implements Iterable<number> {
  *[Symbol.iterator](): Iterator<number> {
    yield 1;
    yield 2;
    yield 3;
  }
}
const collection = new AsyncIterableCollection(new MyIterable());

Works with any AsyncIterable.

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

class MyIterable implements AsyncIterable<number> {
  async *[Symbol.iterator](): Iterator<number> {
    yield 1;
    yield 2;
    yield 3;
  }
}
const collection = new AsyncIterableCollection(new MyIterable());

Methods

[asyncIterator]

"[asyncIterator]"(): AsyncIterator<TInput, any, any>
Returns AsyncIterator<TInput, any, any>
Implementation of IAsyncCollection.[asyncIterator]
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:311

after

after(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<null | TInput>

The after method returns the item that comes after the first item that matches predicateFn. If the collection is empty or the predicateFn does not match or matches the last item then null is returned.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<null | TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .after(item => item === 2);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .after(item => item === 4);
  // null
}

afterOr

afterOr<TExtended = TInput>(
defaultValue: AsyncLazyable<TExtended>,
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<TInput | TExtended>

The afterOr method returns the item that comes after the first item that matches predicateFn. If the collection is empty or the predicateFn does not match or matches the last item then defaultValue is returned.

Type Parameters

TExtended = TInput

Parameters

defaultValue: AsyncLazyable<TExtended>
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOr(-1, item => item === 2);
  // 3
}

You can pass a function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOr(() => -1, item => item === 4);
  // -1
}

You can pass an async function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOr(async () => -1, item => item === 4);
  // -1
}

You can pass a LazyPromise as default value.

Example

import type { IAsyncCollection, ICache } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOr(cache.get("a"), item => item > 10);
  // -1
}

afterOrFail

afterOrFail(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<TInput>

The afterOrFail method returns the item that comes after the first item that matches predicateFn. If the collection is empty or the predicateFn does not match or matches the last item then an error is thrown.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<TInput>

Throws

ItemNotFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOrFail(item => item === 2);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .afterOrFail(item => item === 4);
  // error is thrown
}

append

append<TExtended = TInput>(
iterable: AsyncIterableValue<TInput | TExtended>,
): IAsyncCollection<TInput | TExtended>
The append method adds iterable to the end of the collection.
Type Parameters
- TExtended = TInput
Parameters
- iterable: AsyncIterableValue<TInput | TExtended>
Returns IAsyncCollection<TInput | TExtended>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .append([-1, -2])
    .toArray();
  // [1, 2, 3, 4, 5, -1, -2,]
}
```
Implementation of IAsyncCollection.append
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:939

average

average(): LazyPromise<Extract<TInput, number>>
The average method returns the average of all items in the collection. If the collection includes other than number items an error will be thrown.

Returns LazyPromise<Extract<TInput, number>>
Throws
TypeCollectionError

Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .average();
  // 2
}
```
Implementation of IAsyncCollection.average
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:506

before

before(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<null | TInput>

The before method returns the item that comes before the first item that matches predicateFn. If the predicateFn does not match or matches the first item then null is returned.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<null | TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
     .append([1, 2, 3, 4])
     .before(item => item === 2);
  // 1
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .before(item => item === 1);
  // null
}

beforeOr

beforeOr<TExtended = TInput>(
defaultValue: AsyncLazyable<TExtended>,
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<TInput | TExtended>

The beforeOr method returns the item that comes before the first item that matches predicateFn. If the collection is empty or the predicateFn does not match or matches the first item then defaultValue is returned.

Type Parameters

TExtended = TInput

Parameters

defaultValue: AsyncLazyable<TExtended>
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOr(-1, item => item === 2);
  // 1
}

You can pass a function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOr(() => -1, item => item === 1);
  // -1
}

You can pass an async function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOr(async () => -1, item => item === 1);
  // -1
}

You can pass a LazyPromise as default value.

Example

import type { IAsyncCollection, ICache } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOr(cache.get("a"), item => item > 10);
  // -1
}

beforeOrFail

beforeOrFail(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<TInput>

The beforeOrFail method returns the item that comes before the first item that matches predicateFn. If the collection is empty or the predicateFn does not match or matches the first item then an error is thrown.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns LazyPromise<TInput>

Throws

ItemNotFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOrFail(item => item === 2);
  // 1
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .beforeOrFail(item => item === 1);
  // error is thrown
}

change

change<TFilterOutput, TMapOutput>(
    predicateFn: AsyncPredicate<
        TInput,
        IAsyncCollection<TInput>,
        TFilterOutput,
    >,
    mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>,
): IAsyncCollection<TInput | TFilterOutput | TMapOutput>
The change method changes only the items that passes predicateFn using mapFn.
Type Parameters
- TFilterOutput
- TMapOutput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>
- mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>
Returns IAsyncCollection<TInput | TFilterOutput | TMapOutput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .change(item => item % 2 === 0, item => item * 2)
    .toArray();
  // [1, 4, 3, 8, 5]
}
```
Implementation of IAsyncCollection.change
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:440

chunk

chunk(chunkSize: number): IAsyncCollection<IAsyncCollection<TInput>>
The chunk method breaks the collection into multiple, smaller collections of size chunkSize. If chunkSize is not divisible with total number of items then the last chunk will contain the remaining items.
Parameters
- chunkSize: number
Returns IAsyncCollection<IAsyncCollection<TInput>>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6, 7])
    .chunk(4)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2, 3, 4], [5, 6, 7]]
}
```
Implementation of IAsyncCollection.chunk
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:779

chunkWhile

chunkWhile(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<IAsyncCollection<TInput>>
The chunkWhile method breaks the collection into multiple, smaller collections based on the evaluation of predicateFn. The chunk variable passed to the predicateFn may be used to inspect the previous item.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns IAsyncCollection<IAsyncCollection<TInput>>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("AABBCCCD")
    .chunkWhile((value, index, chunk) => {
      return value === chunk.last();
    })
    .map(chunk => chunk.toArray())
    .toArray();
  //  [["A", "A"], ["B", "B"], ["C", "C", "C"], ["D"]]
}
```
Implementation of IAsyncCollection.chunkWhile
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:789

collapse

collapse(): IAsyncCollection<AsyncCollapse<TInput>>

The collapse method collapses a collection of iterables into a single, flat collection.

Returns IAsyncCollection<AsyncCollapse<TInput>>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number[]>): Promise<void> {
  await collection
    .append([[1, 2], [3, 4]])
    .collapse()
    .toArray();
  // [1, 2, 3, 4]
}

count

count(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<number>
The count method returns the total number of items in the collection that passes predicateFn.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns LazyPromise<number>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .count(value => value % 2 === 0);
  // 3
}
```
Implementation of IAsyncCollection.count
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1188

countBy

countBy<TOutput = TInput>(
selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<[TOutput, number]>

The countBy method counts the occurrences of values in the collection by selectFn. By default the equality check occurs on the item.

Type Parameters

TOutput = TInput

Parameters

OptionalselectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>

Returns IAsyncCollection<[TOutput, number]>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
     .append(["a", "a", "a", "b", "b", "c"])
    .countBy()
    .map(([key, collection]) => [key, collection.toArray()])
    .toArray();
  // [
  //  ["a", 3],
  //  ["b", 2],
  //  ["c", 1]
  // ]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["alice@gmail.com", "bob@yahoo.com", "carlos@gmail.com"])
    .countBy(item => item.split("@")[1])
    .toArray();
  // [
  //   ["gmail.com", 2],
  //   ["yahoo.com", 1]
  // ]
}

crossJoin

crossJoin<TExtended>(
iterable: AsyncIterableValue<TExtended>,
): IAsyncCollection<CrossJoinResult<TInput, TExtended>>

The crossJoin method cross joins the collection's values among iterables, returning a Cartesian product with all possible permutations.

Type Parameters

TExtended

Parameters

iterable: AsyncIterableValue<TExtended>

Returns IAsyncCollection<CrossJoinResult<TInput, TExtended>>

Example

import { ICollection } from "@daiso-tech/core";;

async function(): Promise<void> {
  await collection
    .append([1, 2])
    .cross(["a", "b"])
    .toArray();
  // [
  //  [1, "a"],
  //  [1, "b"],
  //  [2, "a"],
  //  [2, "b"],
  // ]
}

Example

import { ICollection } from "@daiso-tech/core";;

async function(): Promise<void> {
  await collection
    .append([1, 2])
    .cross(["a", "b"])
    .cross(["I", "II"])
    .toArray();
  // [
  //  [1, "a", "I"],
  //  [1, "a", "II"],
  //  [1, "b", "I"],
  //  [1, "b", "II"],
  //  [2, "a", "I"],
  //  [2, "a", "II"],
  //  [2, "b", "I"],
  //  [2, "b", "II"],
  // ]
}

difference

difference<TOutput = TInput>(
iterable: AsyncIterableValue<TInput>,
selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<TInput>

The difference method will return the values in the original collection that are not present in iterable. By default the equality check occurs on the item.

Type Parameters

TOutput = TInput

Parameters

iterable: AsyncIterableValue<TInput>
selectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput> = ...

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 2, 3, 4, 5])
    .difference([2, 4, 6, 8])
    .toArray();
  // [1, 3, 5]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

type Phone = {
  name: string;
  brand: string;
  type: string;
};

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<Phone>): Promise<void> {
  await collection
    .append([
      { name: "iPhone 6", brand: "Apple", type: "phone" },
      { name: "iPhone 5", brand: "Apple", type: "phone" },
      { name: "Apple Watch", brand: "Apple", type: "watch" },
      { name: "Galaxy S6", brand: "Samsung", type: "phone" },
      { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
    ])
    .difference(
      [
        { name: "Apple Watch", brand: "Apple", type: "watch" },
      ],
      (product) => product.type
    )
    .toArray();
  // [
  //   { name: "iPhone 6", brand: "Apple", type: "phone" },
  //   { name: "iPhone 5", brand: "Apple", type: "phone" },
  //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
  // ]
}

entries

entries(): IAsyncCollection<[number, TInput]>
The entries returns an IAsyncCollection of key, value pairs for every entry in the collection.

Returns IAsyncCollection<[number, TInput]>
Implementation of IAsyncCollection.entries
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:319

every

every<TOutput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<boolean>
The every method determines whether all items in the collection matches predicateFn.
Type Parameters
- TOutput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>
Returns LazyPromise<boolean>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([0, 1, 2, 3, 4, 5])
    .every(item => item < 6);
  // true
}
```
Implementation of IAsyncCollection.every
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:656

filter

filter<TOutput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<TOutput>
The filter method filters the collection using predicateFn, keeping only those items that pass predicateFn.
Type Parameters
- TOutput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>
Returns IAsyncCollection<TOutput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .filter(item => 2 < item && item < 5)
    .toArray();
  // [3, 4]
}
```
Implementation of IAsyncCollection.filter
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:331

first

first<TOutput>(
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<null | TOutput>

The first method returns the first item in the collection that passes predicateFn. By default it will get the first item. If the collection is empty or no items passes predicateFn than null i returned.

Type Parameters

TOutput

Parameters

OptionalpredicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<null | TOutput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .first();
  // 1
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .first(item => item > 2);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .first(item => item > 10);
  // null
}

firstOr

firstOr<TOutput, TExtended = TInput>(
defaultValue: AsyncLazyable<TExtended>,
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput | TExtended>

The firstOr method returns the first item in the collection that passes predicateFn By default it will get the first item. If the collection is empty or no items passes predicateFn than defaultValue.

Type Parameters

TOutput
TExtended = TInput

Parameters

defaultValue: AsyncLazyable<TExtended>
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput> = ...

Returns LazyPromise<TOutput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOr(-1);
  // 1
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOr(-1, item => item > 2);
  // 3
}

You can pass a function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOr(() => -1, item => item > 10);
  // -1
}

You can pass an async function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOr(async () => -1, item => item > 10);
  // -1
}

You can pass a LazyPromise as default value.

Example

import type { IAsyncCollection, ICache } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOr(cache.get("a"), item => item > 10);
  // -1
}

firstOrFail

firstOrFail<TOutput>(
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput>

The firstOrFail method returns the first item in the collection that passes predicateFn. By default it will get the first item. If the collection is empty or no items passes predicateFn than error is thrown.

Type Parameters

TOutput

Parameters

OptionalpredicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<TOutput>

Throws

ItemNotFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOrFail();
  // 1
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOrFail(item => item > 2);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .firstOrFail(item => item > 10);
  // throws an error
}

flatMap

flatMap<TOutput>(
    mapFn: AsyncMap<
        TInput,
        IAsyncCollection<TInput>,
        Iterable<TOutput, any, any>,
    >,
): IAsyncCollection<TOutput>
The flatMap method returns a new array formed by applying mapFn to each item of the array, and then collapses the result by one level. It is identical to a map method followed by a collapse method.
Type Parameters
- TOutput
Parameters
- mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput, any, any>>
Returns IAsyncCollection<TOutput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string[]>): Promise<void> {
  await collection
    .append([["a", "b"], ["c", "d"]])
    .flatMap(item => [item.length, ...item])
    .toArray();
  // [2, "a", "b", 2, "c", "d"]
}
```
Implementation of IAsyncCollection.flatMap
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:432

forEach

forEach(
callback: AsyncForEach<TInput, IAsyncCollection<TInput>>,
): LazyPromise<void>
The forEach method iterates through all items in the collection.
Parameters
- callback: AsyncForEach<TInput, IAsyncCollection<TInput>>
Returns LazyPromise<void>
Implementation of IAsyncCollection.forEach
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1248

get

get(index: number): LazyPromise<null | TInput>

The get method returns the item by index. If the item is not found null will returned.

Parameters

index: number

Returns LazyPromise<null | TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
   collection = collection.append([1, 4, 2, 8, -2]);

   // Will be 2
   await collection.get(2);

   // Will be null
   await collection.get(5);
}

getOrFail

getOrFail(index: number): LazyPromise<TInput>

The getOrFail method returns the item by index. If the item is not found an error will be thrown.

Parameters

index: number

Returns LazyPromise<TInput>

Throws

ItemNotFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  collection = collection.append([1, 4, 2, 8, -2]);

  // Will be 2
  await collection.getOrFail(2);

  // An error will thrown
  await collection.getOrFail(5);
}

groupBy

groupBy<TOutput = TInput>(
selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<[TOutput, IAsyncCollection<TInput>]>

The groupBy method groups the collection's items by selectFn. By default the equality check occurs on the item.

Type Parameters

TOutput = TInput

Parameters

OptionalselectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>

Returns IAsyncCollection<[TOutput, IAsyncCollection<TInput>]>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "a", "a", "b", "b", "c"])
    .groupBy()
    .map(([key, collection]) => [key, collection.toArray()])
    .toArray();
  // [
  //  [
  //    "a",
  //    ["a", "a", "a"]
  //  ],
  //  [
  //    "b",
  //    ["b", "b"]
  //  ],
  //  [
  //    "c",
  //    ["c"]
  //  ]
  // ]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["alice@gmail.com", "bob@yahoo.com", "carlos@gmail.com"])
    .groupBy(item => item.split("@")[1])
    .map(([key, collection]) => [key, collection.toArray()])
    .toArray();
  // [
  //   [
  //     "gmail.com",
  //     ["alice@gmail.com", "carlos@gmail.com"]
  //   ],
  //   [
  //     "yahoo.com",
  //     ["bob@yahoo.com"]
  //   ]
  // ]
}

insertAfter

insertAfter<TExtended = TInput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
iterable: AsyncIterableValue<TInput | TExtended>,
): IAsyncCollection<TInput | TExtended>
The insertAfter method adds iterable after the first item that matches predicateFn.
Type Parameters
- TExtended = TInput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
- iterable: AsyncIterableValue<TInput | TExtended>
Returns IAsyncCollection<TInput | TExtended>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 2, 3, 4, 5])
    .insertAfter(item => item === 2, [-1, 20])
    .toArray();
  // [1, 2, -1, 20, 2, 3, 4, 5]
}
```
Implementation of IAsyncCollection.insertAfter
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:956

insertBefore

insertBefore<TExtended = TInput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
iterable: AsyncIterableValue<TInput | TExtended>,
): IAsyncCollection<TInput | TExtended>
The insertBefore method adds iterable before the first item that matches predicateFn.
Type Parameters
- TExtended = TInput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
- iterable: AsyncIterableValue<TInput | TExtended>
Returns IAsyncCollection<TInput | TExtended>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 2, 3, 4, 5])
    .insertBefore(item => item === 2, [-1, 20])
    .toArray();
  // [1, -1, 20, 2, 2, 3, 4, 5]
}
```
Implementation of IAsyncCollection.insertBefore
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:947

isEmpty

isEmpty(): LazyPromise<boolean>
The isEmpty returns true if the collection is empty.

Returns LazyPromise<boolean>
Implementation of IAsyncCollection.isEmpty
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1206

isNotEmpty

isNotEmpty(): LazyPromise<boolean>
The isNotEmpty returns true if the collection is not empty.

Returns LazyPromise<boolean>
Implementation of IAsyncCollection.isNotEmpty
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1215

join

join(separator?: string): LazyPromise<Extract<TInput, string>>

The join method joins the collection's items with separator. An error will be thrown when if a none string item is encounterd.

Parameters

separator: string = ","

Returns LazyPromise<Extract<TInput, string>>

Throws

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .map(item => item.toString())
    .join();
  // "1,2,3,4"
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .map(item => item.toString())
    .join("_");
  // "1_2_3_4"
}

keys

keys(): IAsyncCollection<number>
The keys method returns an IAsyncCollection of keys in the collection.

Returns IAsyncCollection<number>
Implementation of IAsyncCollection.keys
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:323

last

last<TOutput>(
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<null | TOutput>

The last method returns the last item in the collection that passes predicateFn. By default it will get the last item. If the collection is empty or no items passes predicateFn than null i returned.

Type Parameters

TOutput

Parameters

OptionalpredicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<null | TOutput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .last();
  // 4
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .last(item => item < 4);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .last(item => item > 10);
  // null
}

lastOr

lastOr<TOutput, TExtended = TInput>(
defaultValue: AsyncLazyable<TExtended>,
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput | TExtended>

The lastOr method returns the last item in the collection that passes predicateFn. By default it will get the last item. If the collection is empty or no items passes predicateFn than defaultValue.

Type Parameters

TOutput
TExtended = TInput

Parameters

defaultValue: AsyncLazyable<TExtended>
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput> = ...

Returns LazyPromise<TOutput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOr(-1);
  // 4
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOr(-1, item => item < 4);
  // 3
}

You can pass a function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOr(() => -1, item => item > 10);
  // -1
}

You can pass an async function as default value.

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOr(async () => -1, item => item > 10);
  // -1
}

You can pass a LazyPromise as default value.

Example

import type { IAsyncCollection, ICache } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>, cache: ICache<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOr(cache.get("a"), item => item > 10);
  // -1
}

lastOrFail

lastOrFail<TOutput>(
predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput>

The lastOrFail method returns the last item in the collection that passes predicateFn. By default it will get the last item. If the collection is empty or no items passes predicateFn than error is thrown.

Type Parameters

TOutput

Parameters

OptionalpredicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<TOutput>

Throws

ItemNotFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOrFail();
  // 4
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOrFail(item => item < 4);
  // 3
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .lastOrFail(item => item > 10);
  // throws an error
}

map

map<TOutput>(
mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<TOutput>
The map method iterates through the collection and passes each item to mapFn. The mapFn is free to modify the item and return it, thus forming a new collection of modified items.
Type Parameters
- TOutput
Parameters
- mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>
Returns IAsyncCollection<TOutput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .map(item => item * 2)
    .toArray();
  // [2, 4, 6, 8, 10]
}
```
Implementation of IAsyncCollection.map
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:348

max

max(): LazyPromise<Extract<TInput, number>>
The max method returns the max of all items in the collection. If the collection includes other than number items an error will be thrown.

Returns LazyPromise<Extract<TInput, number>>
Throws
TypeCollectionError

Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .max();
  // 3
}
```
Implementation of IAsyncCollection.max
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:598

median

median(): LazyPromise<Extract<TInput, number>>
The median method returns the median of all items in the collection. If the collection includes other than number items an error will be thrown.

Returns LazyPromise<Extract<TInput, number>>
Throws
TypeCollectionError

Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .median();
  // 2
}
```
Implementation of IAsyncCollection.median
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:528

min

min(): LazyPromise<Extract<TInput, number>>
The min method returns the min of all items in the collection. If the collection includes other than number items an error will be thrown.

Returns LazyPromise<Extract<TInput, number>>
Throws
TypeCollectionError

Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .min();
  // 1
}
```
Implementation of IAsyncCollection.min
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:574

nth

nth(step: number): IAsyncCollection<TInput>

The nth method creates a new collection consisting of every n-th item.

Parameters

step: number

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection.append(["a", "b", "c", "d", "e", "f"])
    .nth(4)
    .toArray();
  // ["a", "e"]
}

padEnd

padEnd<TExtended = TInput>(
maxLength: number,
fillItems: AsyncIterableValue<TExtended>,
): IAsyncCollection<TInput | TExtended>

The padEnd method pads this collection with fillItems until the resulting collection size reaches maxLength. The padding is applied from the end of this collection.

Type Parameters

TExtended = TInput

Parameters

maxLength: number
fillItems: AsyncIterableValue<TExtended>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padEnd(10, "foo")
    .join("");
  // "abcfoofoof"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padEnd(6, "123465")
    .join("");
  // "abc123"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padEnd(8, "0")
    .join("");
  // "abc00000"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padEnd(1, "_")
    .join("");
  // "abc"
}

padStart

padStart<TExtended = TInput>(
maxLength: number,
fillItems: AsyncIterableValue<TExtended>,
): IAsyncCollection<TInput | TExtended>

The padStart method pads this collection with fillItems until the resulting collection size reaches maxLength. The padding is applied from the start of this collection.

Type Parameters

TExtended = TInput

Parameters

maxLength: number
fillItems: AsyncIterableValue<TExtended>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padStart(10, "foo")
    .join("");
  // "foofoofabc"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padStart(6, "123465")
    .join("");
  // "123abc"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padStart(8, "0")
    .join("");
  // "00000abc"
}

Example

async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append("abc")
    .padStart(1, "_")
    .join("");
  // "abc"
}

page

page(page: number, pageSize: number): IAsyncCollection<TInput>
The page method returns a new collection containing the items that would be present on page with custom pageSize.
Parameters
- page: number
- pageSize: number
Returns IAsyncCollection<TInput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6, 7, 8, 9])
    .page(2, 3)
    .toArray();
  // [4, 5, 6]
}
```
Implementation of IAsyncCollection.page
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:479

partition

partition(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<IAsyncCollection<TInput>>

The partition method is used to separate items that pass predicateFn from those that do not.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns IAsyncCollection<IAsyncCollection<TInput>>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .partition(item => item < 3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [3, 4, 5, 6]]
}

percentage

percentage(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<number>
The percentage method may be used to quickly determine the percentage of items in the collection that pass predicateFn.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns LazyPromise<number>
Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 1, 2, 2, 2, 3])
    .percentage(value => value === 1);
  // 33.333
}
```
Implementation of IAsyncCollection.percentage
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:622

pipe

pipe<TOutput = TInput>(
callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput>

The pipe method passes the orignal collection to callback and returns the result from callback. This method is useful when you want compose multiple smaller functions.

Type Parameters

TOutput = TInput

Parameters

callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<TOutput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  function toNbrs<TInput>(
    collection: IAsyncCollection<TInput>,
  ): IAsyncCollection<number> {
    return collection
      .map((item) => Number(item))
      .reject((nbr) => Number.isNaN(nbr));
  }
  function nbrToStr(collection: IAsyncCollection<number>): number[] {
    return collection.repeat(2).toArray();
  }
  await collection
    .append([1, "2", "a", 1, 3, {}])
    .pipe(toNbrs)
    .then(nbrToStr);
  // [ 1, 2, 1, 3 ]
}

prepend

prepend<TExtended = TInput>(
iterable: AsyncIterableValue<TInput | TExtended>,
): IAsyncCollection<TInput | TExtended>
The prepend method adds iterable to the beginning of the collection.
Type Parameters
- TExtended = TInput
Parameters
- iterable: AsyncIterableValue<TInput | TExtended>
Returns IAsyncCollection<TInput | TExtended>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .prepend([-1, 20])
    .toArray();
  // [-1, 20, 1, 2, 3, 4, 5]
}
```
Implementation of IAsyncCollection.prepend
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:931

reduce

reduce(
reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>,
): LazyPromise<TInput>

The reduce method executes reduceFn function on each item of the array, passing in the return value from the calculation on the preceding item. The final result of running the reducer across all items of the array is a single value.

Parameters

reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>

Returns LazyPromise<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .reduce((sum, item) => sum + item);
  // 6
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c"])
    .entries()
    .reduce(
      (record, [key, value]) => ({
        ...record,
        [key]: value
      }),
      {} as Record<number, string>
    );
  // { 0: "a", 1: "b", 2: "c" }
}

reduce(
reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>,
initialValue: TInput,
): LazyPromise<TInput>
Parameters
- reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>
- initialValue: TInput
Returns LazyPromise<TInput>
Implementation of IAsyncCollection.reduce
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:357
reduce<TOutput>(
reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>,
initialValue: TOutput,
): LazyPromise<TOutput>
Type Parameters
- TOutput
Parameters
- reduce: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>
- initialValue: TOutput
Returns LazyPromise<TOutput>
Implementation of IAsyncCollection.reduce
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:362

reject

reject<TOutput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<Exclude<TInput, TOutput>>
The reject method filters the collection using predicateFn, keeping only those items that not pass predicateFn.
Type Parameters
- TOutput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>
Returns IAsyncCollection<Exclude<TInput, TOutput>>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .reject(item => 2 < item && item < 5)
    .toArray();
  // [1, 2, 5, 6]
}
```
Implementation of IAsyncCollection.reject
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:339

repeat

repeat(amount: number): IAsyncCollection<TInput>

The repeat method will repeat the original collection amount times.

Parameters

amount: number

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .repeat(3)
    .toArray();
  // [1, 2, 3,  1, 2, 3,  1, 2, 3]
}

reverse

reverse(chunkSize?: number): IAsyncCollection<TInput>
The reverse method will reverse the order of the collection. The reversing of the collection will be applied in chunks that are the size of chunkSize.
Parameters
- OptionalchunkSize: number
Returns IAsyncCollection<TInput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([-1, 2, 4, 3])
    .reverse()
    .toArray();
  // [3, 4, 2, -1]
}
```
Implementation of IAsyncCollection.reverse
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:991

searchFirst

searchFirst(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<number>
The searchFirst return the index of the first item that matches predicateFn.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns LazyPromise<number>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "b", "c"])
    .searchFirst(item => item === "b");
  // 1
}
```
Implementation of IAsyncCollection.searchFirst
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1221

searchLast

searchLast(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): LazyPromise<number>
The searchLast return the index of the last item that matches predicateFn.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns LazyPromise<number>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "b", "c"])
    .searchLast(item => item === "b");
  // 2
}
```
Implementation of IAsyncCollection.searchLast
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1234

set

set(
index: number,
value: TInput | AsyncMap<TInput, IAsyncCollection<TInput>, TInput>,
): IAsyncCollection<TInput>

The set method changes a item by i>indexusingvalue`.

Parameters

index: number
value: TInput | AsyncMap<TInput, IAsyncCollection<TInput>, TInput>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .set(1, -1)
    .toArray();
  // [1, -1, 3, 4, 5]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .set(1, (prevValue) => prevValue - 2)
    .toArray();
  // [1, 0, 3, 4, 5]
}

shuffle

shuffle(mathRandom?: () => number): IAsyncCollection<TInput>
The shuffle method randomly shuffles the items in the collection. You can provide a custom Math.random function by passing in mathRandom.
Parameters
- mathRandom: () => number = Math.random
  - - (): number
    - Returns a pseudorandom number between 0 and 1.
      
      Returns number
Returns IAsyncCollection<TInput>
Implementation of IAsyncCollection.shuffle
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1001

size

size(): LazyPromise<number>
The size returns the size of the collection.

Returns LazyPromise<number>
Implementation of IAsyncCollection.size
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1202

skip

skip(offset: number): IAsyncCollection<TInput>

The skip method skips the first offset items.

Parameters

offset: number

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .skip(4)
    .toArray();
  // [5, 6, 7, 8, 9, 10]
}

skipUntil

skipUntil(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<TInput>

The skipUntil method skips items until predicateFn returns true.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .skipUntil(item => item >= 3)
    .toArray();
  // [3, 4]
}

skipWhile

skipWhile(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<TInput>
The skipWhile method skips items until predicateFn returns false.
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>
Returns IAsyncCollection<TInput>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .skipWhile(item => item <= 3)
  .toArray();
  // [4]
}
```
Implementation of IAsyncCollection.skipWhile
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:708

slice

slice(start?: number, end?: number): IAsyncCollection<TInput>

The slice method creates porition of the original collection selected from start and end where start and end (end not included) represent the index of items in the collection.

Parameters

Optionalstart: number
Optionalend: number

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(3)
    .toArray();
  // ["d", "e", "f"]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(undefined, 2)
    .toArray();
  // ["a", "b"]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(2, 5)
    .toArray();
  // ["c", "d", "e"]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(-2)
    .toArray();
  // ["e", "f"]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(undefined, -2)
    .toArray();
  // ["a", "b", "c", "d"]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["a", "b", "c", "d", "e", "f"])
    .slice(-4, -2)
    .toArray();
  // ["c", "d"]
}

sliding

sliding(
chunkSize: number,
step?: number,
): IAsyncCollection<IAsyncCollection<TInput>>

The sliding method returns a new collection of chunks representing a "sliding window" view of the items in the collection.

Parameters

chunkSize: number
step: number = ...

Returns IAsyncCollection<IAsyncCollection<TInput>>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .sliding(2)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [2, 3], [3, 4], [4, 5]]
}

sole

sole<TOutput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<TOutput>

The sole method returns the first item in the collection that passes predicateFn, but only if predicateFn matches exactly one item. If no items matches or multiple items are found an error will be thrown.

Type Parameters

TOutput

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>

Returns LazyPromise<TOutput>

Throws

ItemNotFoundCollectionError

Throws

MultipleItemsFoundCollectionError

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .sole(item => item === 4);
  // 4
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 4, 5])
    .sole(item => item === 4);
  // error is thrown
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 5])
    .sole(item => item === 4);
  // error is thrown
}

some

some<TOutput>(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>,
): LazyPromise<boolean>
The some method determines whether at least one item in the collection matches predicateFn.
Type Parameters
- TOutput
Parameters
- predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>
Returns LazyPromise<boolean>
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([0, 1, 2, 3, 4, 5])
    .some(item => item === 1);
  // true
}
```
Implementation of IAsyncCollection.some
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:643

sort

sort(comparator?: Comparator<TInput>): IAsyncCollection<TInput>

The sort method sorts the collection. You can provide a comparator function.

Parameters

Optionalcomparator: Comparator<TInput>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

type Person = {
  name: string;
  age: number;
};

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<Person>): Promise<void> {
  await collection
    .append([-1, 2, 4, 3])
    .sort()
    .toArray();
  // [-1, 2, 3, 4]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([
      { name: "Anders", age: 30 },
      { name: "Joe", age: 20 },
      { name: "Hasan", age: 25 },
      { name: "Linda", age: 19 }
    ])
    .sort(({ age: ageA }, { age: ageB }) => ageA - ageB)
    .toArray();
  // [
  //   { name: "Linda", age: 19 }
  //   { name: "Joe", age: 20 },
  //   { name: "Hasan", age: 25 },
  //   { name: "Anders", age: 30 },
  // ]
}

split

split(chunkAmount: number): IAsyncCollection<IAsyncCollection<TInput>>

The split method breaks a collection evenly into chunkAmount of chunks.

Parameters

chunkAmount: number

Returns IAsyncCollection<IAsyncCollection<TInput>>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [3, 4], [5]]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [3, 4], [5, 6]]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6, 7])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2, 7], [3, 4], [5, 6]]

sum

sum(): LazyPromise<Extract<TInput, number>>
The sum method returns the sum of all items in the collection. If the collection includes other than number items an error will be thrown.

Returns LazyPromise<Extract<TInput, number>>
Throws
TypeCollectionError

Throws
EmptyCollectionError
Example
```
import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3])
    .sum();
  // 6
}
```
Implementation of IAsyncCollection.sum
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:486

take

take(limit: number): IAsyncCollection<TInput>

The take method takes the first limit items.

Parameters

limit: number

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([0, 1, 2, 3, 4, 5])
    .take(3)
    .toArray();
  // [0, 1, 2]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([0, 1, 2, 3, 4, 5])
    .take(-2)
    .toArray();
  // [0, 1, 2, 3]
}

takeUntil

takeUntil(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<TInput>

The takeUntil method takes items until predicateFn returns true.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .takeUntil(item => item >= 3)
    .toArray();
  // [1, 2]
}

takeWhile

takeWhile(
predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>,
): IAsyncCollection<TInput>

The takeWhile method takes items until predicateFn returns false.

Parameters

predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .takeWhile(item => item < 4)
    .toArray();
  // [1, 2, 3]
}

tap

tap(callback: AsyncTap<IAsyncCollection<TInput>>): IAsyncCollection<TInput>

The tap method passes a copy of the original collection to callback, allowing you to do something with the items while not affecting the original collection.

Parameters

callback: AsyncTap<IAsyncCollection<TInput>>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4, 5, 6])
    .tap(collection => {
      collection
        .filter(value => value % 2 === 0)
        .forEach(value => console.log(value))
    })
    .toArray();
  // [1, 2, 3, 4, 5, 6]
}

toArray

toArray(): LazyPromise<TInput[]>
The toArray method converts the collection to a new Array | Array.

Returns LazyPromise<TInput[]>
Implementation of IAsyncCollection.toArray
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1258

toIterator

toIterator(): AsyncIterator<TInput, void, any>
The toIterator method converts the collection to a new iterator.

Returns AsyncIterator<TInput, void, any>
Implementation of IAsyncCollection.toIterator
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:315

toMap

toMap(): LazyPromise<EnsureMap<TInput>>
The toMap method converts the collection to a new Map. An error will be thrown if item is not a tuple of size 2.

Returns LazyPromise<EnsureMap<TInput>>
Throws
TypeCollectionError
Implementation of IAsyncCollection.toMap
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1300

toRecord

toRecord(): LazyPromise<EnsureRecord<TInput>>
The toRecord method converts the collection to a new Record | Record. An error will be thrown if item is not a tuple of size 2 where the first element is a string or a number.

Returns LazyPromise<EnsureRecord<TInput>>
Throws
TypeCollectionError
Implementation of IAsyncCollection.toRecord
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:1268

unique

unique<TOutput = TInput>(
selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>,
): IAsyncCollection<TInput>

The unique method removes all duplicate values from the collection by selectFn. By default the equality check occurs on the item.

Type Parameters

TOutput = TInput

Parameters

OptionalselectFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>

Returns IAsyncCollection<TInput>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

type Phone = {
  name: string;
  brand: string;
  type: string;
};

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<Phone>): Promise<void> {
  await collection
    .append([1, 1, 2, 2, 3, 4, 2])
    .unique()
    .toArray();
  // [1, 2, 3, 4]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([
      { name: "iPhone 6", brand: "Apple", type: "phone" },
      { name: "iPhone 5", brand: "Apple", type: "phone" },
      { name: "Apple Watch", brand: "Apple", type: "watch" },
      { name: "Galaxy S6", brand: "Samsung", type: "phone" },
      { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
    ])
    .unique(item => item.brand)
    .toArray();
  // [
  //   { name: "iPhone 6", brand: "Apple", type: "phone" },
  //   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
  // ]
}

values

values(): IAsyncCollection<TInput>
The values method returns a copy of the collection.

Returns IAsyncCollection<TInput>
Implementation of IAsyncCollection.values
- Defined in src/collection/implementations/async-iterable-collection/async-iterable-collection.ts:327

when

when<TExtended = TInput>(
    condition: boolean,
    callback: AsyncModifier<
        IAsyncCollection<TInput>,
        IAsyncCollection<TExtended>,
    >,
): IAsyncCollection<TInput | TExtended>

The when method will execute callback when condition evaluates to true.

Type Parameters

TExtended = TInput

Parameters

condition: boolean
callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .when(true, collection => collection.append([-3]))
    .when(false, collection => collection.append([20]))
    .toArray();
  // [1, 2, 3, 4, -3]
}

whenEmpty

whenEmpty<TExtended = TInput>(
    callback: AsyncModifier<
        IAsyncCollection<TInput>,
        IAsyncCollection<TExtended>,
    >,
): IAsyncCollection<TInput | TExtended>

The whenEmpty method will execute callback when the collection is empty.

Type Parameters

TExtended = TInput

Parameters

callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([])
    .whenEmpty(collection => collection.append([-3]))
    .toArray();
  // [-3]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1])
    .whenEmpty(collection => collection.append([-3]))
    .toArray();
  // [1]
}

whenNot

whenNot<TExtended = TInput>(
    condition: boolean,
    callback: AsyncModifier<
        IAsyncCollection<TInput>,
        IAsyncCollection<TExtended>,
    >,
): IAsyncCollection<TInput | TExtended>

The whenNot method will execute callback when condition evaluates to false.

Type Parameters

TExtended = TInput

Parameters

condition: boolean
callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1, 2, 3, 4])
    .whenNot(true, collection => collection.append([-3]))
    .whenNot(false, collection => collection.append([20]))
    .toArray();
  // [1, 2, 3, 4, 20]
}

whenNotEmpty

whenNotEmpty<TExtended = TInput>(
    callback: AsyncModifier<
        IAsyncCollection<TInput>,
        IAsyncCollection<TExtended>,
    >,
): IAsyncCollection<TInput | TExtended>

The whenNotEmpty method will execute callback when the collection is not empty.

Type Parameters

TExtended = TInput

Parameters

callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>

Returns IAsyncCollection<TInput | TExtended>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([])
    .whenNotEmpty(collection => collection.append([-3])).toArray();
  // []
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<number>): Promise<void> {
  await collection
    .append([1])
    .whenNotEmpty(collection => collection.append([-3]))
    .toArray();
  // [1, -3]
}

zip

zip<TExtended>(
iterable: AsyncIterableValue<TExtended>,
): IAsyncCollection<[TInput, TExtended]>

The zip method merges together the values of iterable with the values of the collection at their corresponding index. The returned collection has size of the shortest collection.

Type Parameters

TExtended

Parameters

iterable: AsyncIterableValue<TExtended>

Returns IAsyncCollection<[TInput, TExtended]>

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["Chair", "Desk"])
    .zip([100, 200])
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["Chair", "Desk", "Couch"])
    .zip([100, 200])
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

Example

import type { IAsyncCollection } from "@daiso-tech/core";

// Asume the inputed collection is empty.
async function main(collection: IAsyncCollection<string>): Promise<void> {
  await collection
    .append(["Chair", "Desk"])
    .zip([100, 200, 300])
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

`Static`concat

concat<TValue>(
iterables: AsyncIterableValue<AsyncIterableValue<TValue>>,
): IAsyncCollection<TValue>

The concat static method is a convenient utility for easily concatenating multiple Iterable | Iterable or AsyncIterable | AsyncIterable.

Type Parameters

TValue

Parameters

iterables: AsyncIterableValue<AsyncIterableValue<TValue>>

Returns IAsyncCollection<TValue>

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

class MyAsyncIterable implements AsyncIterable<number> {
  async *[Symbol.iterator](): Iterator<number> {
    yield "a";
    yield "b";
    yield "c";
  }
}

class MyIterable implements Iterable<number> {
  *[Symbol.iterator](): Iterator<number> {
    yield 1;
    yield 2;
    yield 3;
  }
}

const collection = AsyncIterableCollection.concat([
  new MyAsyncIterable(),
  new MyIterable(),
  new Set([1, 2, 3]),
  new Map([["a", 1], ["b", 2]]),
  ["a", "b", "c"]
]);
await collection.toArray();
// ["a", "b", "c", 1, 2, 3, 1, 2, 3, ["a", 1], ["b", 2], "a", "b", "c"]

`Static`difference

difference<TValue, TSelect>(
    iterableA: AsyncIterableValue<TValue>,
    iterableB: AsyncIterableValue<TValue>,
    selectFn?: AsyncMap<TValue, IAsyncCollection<TValue>, TSelect>,
): IAsyncCollection<TValue>

The difference static method is used to compute the difference between two Iterable | Iterable instances. By default, the equality check is performed on each item.

Type Parameters

TValue
TSelect

Parameters

iterableA: AsyncIterableValue<TValue>
iterableB: AsyncIterableValue<TValue>
OptionalselectFn: AsyncMap<TValue, IAsyncCollection<TValue>, TSelect>

Returns IAsyncCollection<TValue>

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = AsyncIterableCollection.difference(
  [1, 2, 2, 3, 4, 5],
  [2, 4, 6, 8]
);
await collection.toArray();
// [1, 3, 5]

Example

import { AsyncIterableCollection } from "@daiso-tech/core";

const collection = AsyncIterableCollection.difference(
  [
    { name: "iPhone 6", brand: "Apple", type: "phone" },
    { name: "iPhone 5", brand: "Apple", type: "phone" },
    { name: "Apple Watch", brand: "Apple", type: "watch" },
    { name: "Galaxy S6", brand: "Samsung", type: "phone" },
    { name: "Galaxy Gear", brand: "Samsung", type: "watch" },
  ],
  [
    { name: "Apple Watch", brand: "Apple", type: "watch" },
  ],
  (product) => product.type
);
await collection.toArray();
// [
//   { name: "iPhone 6", brand: "Apple", type: "phone" },
//   { name: "iPhone 5", brand: "Apple", type: "phone" },
//   { name: "Galaxy S6", brand: "Samsung", type: "phone" },
// ]

`Static`zip

zip<TValueA, TValueB>(
iterableA: AsyncIterableValue<TValueA>,
iterableB: AsyncIterableValue<TValueB>,
): IAsyncCollection<[TValueA, TValueB]>

The zip static method merges together the values of iterableA with the values of the iterableB at their corresponding index. The returned collection has size of the shortest collection.

Type Parameters

TValueA
TValueB

Parameters

iterableA: AsyncIterableValue<TValueA>
iterableB: AsyncIterableValue<TValueB>

Returns IAsyncCollection<[TValueA, TValueB]>

Example

import { AsyncIterableCollection } from "@daiso-tech/core";;

const collection = AsyncIterableCollection.zip(["Chair", "Desk"], [100, 200]);
await collection.toArray();
// [["Chair", 100], ["Desk", 200]]

Example

import { AsyncIterableCollection } from "@daiso-tech/core";;

const collection = AsyncIterableCollection.zip(["Chair", "Desk", "Couch"], [100, 200]);
await collection.toArray();
// [["Chair", 100], ["Desk", 200]]

Example

import { AsyncIterableCollection } from "@daiso-tech/core";;

const collection = AsyncIterableCollection.zip(["Chair", "Desk"], [100, 200, 300]);
await collection.toArray();
// [["Chair", 100], ["Desk", 200]]

Class AsyncIterableCollection<TInput>

Type Parameters

Implements

Index

Constructors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns AsyncIterableCollection<TInput>

Example

Example

Example

Example

Example

Example

Methods

[asyncIterator]

Returns AsyncIterator<TInput, any, any>

after

Parameters

Returns LazyPromise<null | TInput>

Example

Example

afterOr

Type Parameters

Parameters

Returns LazyPromise<TInput | TExtended>

Example

Example

Example

Example

afterOrFail

Parameters

Returns LazyPromise<TInput>

Throws

Example

Example

append

Type Parameters

Parameters

Returns IAsyncCollection<TInput | TExtended>

Example

average

Returns LazyPromise<Extract<TInput, number>>

Throws

Throws

Example

before

Parameters

Returns LazyPromise<null | TInput>

Example

Example

beforeOr

Type Parameters

Parameters

Returns LazyPromise<TInput | TExtended>

Example

Example

Example

Example

beforeOrFail

Parameters

Returns LazyPromise<TInput>

Throws

Example

Example

change

Type Parameters

Parameters

Returns IAsyncCollection<TInput | TFilterOutput | TMapOutput>

Example

chunk

Parameters

Returns IAsyncCollection<IAsyncCollection<TInput>>

Example

chunkWhile

Parameters

Returns IAsyncCollection<IAsyncCollection<TInput>>