Type Alias IAsyncCollection<TInput>

Type declaration

• after:function

  • 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
    }
    Copy

    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
    }
    Copy

• afterOr:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• afterOrFail:function

  • 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
    }
    Copy

    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
    }
    Copy

• append:function

  • 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,]
    }
    Copy

• average:function

  • 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
    }
    Copy

• before:function

  • 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
    }
    Copy

    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
    }
    Copy

• beforeOr:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• beforeOrFail:function

  • 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
    }
    Copy

    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
    }
    Copy

• change:function

  • 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]
    }
    Copy

• chunk:function

  • 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]]
    }
    Copy

• chunkWhile:function

  • 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"]]
    }
    Copy

• collapse:function

  • 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]
    }
    Copy

• count:function

  • 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
    }
    Copy

• countBy:function

  • 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]
      // ]
    }
    Copy

    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]
      // ]
    }
    Copy

• crossJoin:function

  • 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"],
      // ]
    }
    Copy

    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"],
      // ]
    }
    Copy

• difference:function

  • 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>
    • OptionalselectFn: 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]
    }
    Copy

    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" },
      // ]
    }
    Copy

• entries:function

  • entries(): IAsyncCollection<[number, TInput]>

  • The entries returns an IAsyncCollection of key, value pairs for every entry in the collection.

    Returns IAsyncCollection<[number, TInput]>

• every:function

  • 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
    }
    Copy

• filter:function

  • 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]
    }
    Copy

• first:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• firstOr:function

  • 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>
    • OptionalpredicateFn: 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• firstOrFail:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• flatMap:function

  • 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"]
    }
    Copy

• forEach:function

  • 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>

• get:function

  • 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);
    }
    Copy

• getOrFail:function

  • 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);
    }
    Copy

• groupBy:function

  • 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"]
      //  ]
      // ]
    }
    Copy

    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"]
      //   ]
      // ]
    }
    Copy

• insertAfter:function

  • 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]
    }
    Copy

• insertBefore:function

  • 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]
    }
    Copy

• isEmpty:function

  • isEmpty(): LazyPromise<boolean>

  • The isEmpty returns true if the collection is empty.

    Returns LazyPromise<boolean>

• isNotEmpty:function

  • isNotEmpty(): LazyPromise<boolean>

  • The isNotEmpty returns true if the collection is not empty.

    Returns LazyPromise<boolean>

• join:function

  • 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

    • Optionalseparator: 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"
    }
    Copy

    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"
    }
    Copy

• keys:function

  • keys(): IAsyncCollection<number>

  • The keys method returns an IAsyncCollection of keys in the collection.

    Returns IAsyncCollection<number>

• last:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• lastOr:function

  • 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>
    • OptionalpredicateFn: 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• lastOrFail:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• map:function

  • 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]
    }
    Copy

• max:function

  • 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
    }
    Copy

• median:function

  • 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
    }
    Copy

• min:function

  • 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
    }
    Copy

• nth:function

  • 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"]
    }
    Copy

• padEnd:function

  • 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"
    }
    Copy

    Example

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

    Example

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

    Example

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

• padStart:function

  • 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"
    }
    Copy

    Example

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

    Example

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

    Example

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

• page:function

  • 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]
    }
    Copy

• partition:function

  • 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]]
    }
    Copy

• percentage:function

  • 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
    }
    Copy

• pipe:function

  • 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 ]
    }
    Copy

• prepend:function

  • 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]
    }
    Copy

• reduce:function

  • reduce(
        reduceFn: 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

    • reduceFn: 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
    }
    Copy

    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" }
    }
    Copy

  • reduce(
        reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>,
        initialValue: TInput,
    ): LazyPromise<TInput>

  • Parameters

    • reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>
    • initialValue: TInput

    Returns LazyPromise<TInput>

  • reduce<TOutput>(
        reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>,
        initialValue: TOutput,
    ): LazyPromise<TOutput>

  • Type Parameters

    • TOutput

    Parameters

    • reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>
    • initialValue: TOutput

    Returns LazyPromise<TOutput>

• reject:function

  • 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]
    }
    Copy

• repeat:function

  • 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]
    }
    Copy

• reverse:function

  • 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]
    }
    Copy

• searchFirst:function

  • 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
    }
    Copy

• searchLast:function

  • 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
    }
    Copy

• set:function

  • 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]
    }
    Copy

    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]
    }
    Copy

• shuffle:function

  • 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

    • OptionalmathRandom: () => number

    Returns IAsyncCollection<TInput>

• size:function

  • size(): LazyPromise<number>

  • The size returns the size of the collection.

    Returns LazyPromise<number>

• skip:function

  • 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]
    }
    Copy

• skipUntil:function

  • 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]
    }
    Copy

• skipWhile:function

  • 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]
    }
    Copy

• slice:function

  • 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"]
    }
    Copy

    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"]
    }
    Copy

    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"]
    }
    Copy

    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"]
    }
    Copy

    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"]
    }
    Copy

    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"]
    }
    Copy

• sliding:function

  • 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
    • Optionalstep: 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]]
    }
    Copy

• sole:function

  • 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
    }
    Copy

    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
    }
    Copy

    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
    }
    Copy

• some:function

  • 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
    }
    Copy

• sort:function

  • 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]
    }
    Copy

    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 },
      // ]
    }
    Copy

• split:function

  • 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]]
    }
    Copy

    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]]
    }
    Copy

    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]]
    
    Copy

• sum:function

  • 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
    }
    Copy

• take:function

  • 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]
    }
    Copy

    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]
    }
    Copy

• takeUntil:function

  • 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]
    }
    Copy

• takeWhile:function

  • 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]
    }
    Copy

• tap:function

  • tap(callback: Tap<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: Tap<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]
    }
    Copy

• toArray:function

  • toArray(): LazyPromise<TInput[]>

  • The toArray method converts the collection to a new Array | Array.

    Returns LazyPromise<TInput[]>

• toIterator:function

  • toIterator(): AsyncIterator<TInput, void, any>

  • The toIterator method converts the collection to a new iterator.

    Returns AsyncIterator<TInput, void, any>

• toMap:function

  • 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

• toRecord:function

  • 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

• unique:function

  • 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]
    }
    Copy

    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" },
      // ]
    }
    Copy

• values:function

  • values(): IAsyncCollection<TInput>

  • The values method returns a copy of the collection.

    Returns IAsyncCollection<TInput>

• when:function

  • 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]
    }
    Copy

• whenEmpty:function

  • 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]
    }
    Copy

    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]
    }
    Copy

• whenNot:function

  • 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]
    }
    Copy

• whenNotEmpty:function

  • 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();
      // []
    }
    Copy

    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]
    }
    Copy

• zip:function

  • 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]]
    }
    Copy

    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]]
    }
    Copy

    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]]
    }
    Copy