Class ListCollection<TInput>

All methods in ListCollection are executed eagerly.

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

Type Parameters

TInput = unknown

Implements

ICollection<TInput>

Constructors

constructor

new ListCollection<TInput = unknown>(
iterable?: Iterable<TInput, any, any>,
): ListCollection<TInput>

The constructor takes an Iterable | Iterable.

Works with Array.

Type Parameters

TInput = unknown

Parameters

iterable: Iterable<TInput, any, any> = []

Returns ListCollection<TInput>

Example

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

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

Works with String.

Example

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

const collection = new ListCollection("ABCDE");

Works with Set.

Example

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

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

Works with Map.

Example

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

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

Works with any Iterable.

Example

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

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

Methods

[iterator]

"[iterator]"(): Iterator<TInput, any, any>
Returns Iterator<TInput, any, any>
Implementation of ICollection.[iterator]
- Defined in src/collection/implementations/list-collection/list-collection.ts:221

after

after(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: PredicateInvokable<TInput, ICollection<TInput>>

Returns null | TInput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .after(item => item === 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .after(item => item === 4);
  // null
}

afterOr

afterOr<TExtended = TInput>(
defaultValue: Lazyable<TExtended>,
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: Lazyable<TExtended>
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns TInput | TExtended

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .afterOr(-1, item => item === 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .afterOr(-1, item => item === 4);
  // -1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .afterOr(() => -1, item => item === 4);
  // -1
}

afterOrFail

afterOrFail(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: PredicateInvokable<TInput, ICollection<TInput>>

Returns TInput

Throws

ItemNotFoundCollectionError

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .afterOrFail(item => item === 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .afterOrFail(item => item === 4);
  // error is thrown
}

append

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5])
    .append([-1, -2])
    .toArray();
  // [1, 2, 3, 4, 5, -1, -2,]
}
```
Implementation of ICollection.append
- Defined in src/collection/implementations/list-collection/list-collection.ts:867

average

average(): 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. If the collection is empty an error will also be thrown.

Returns Extract<TInput, number>
Throws
TypeCollectionError

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3])
    .average()
  // 2
}
```
Implementation of ICollection.average
- Defined in src/collection/implementations/list-collection/list-collection.ts:423

before

before(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: PredicateInvokable<TInput, ICollection<TInput>>

Returns null | TInput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .before(item => item === 2);
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .before(item => item === 1);
  // null
}

beforeOr

beforeOr<TExtended = TInput>(
defaultValue: Lazyable<TExtended>,
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: Lazyable<TExtended>
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns TInput | TExtended

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .beforeOr(-1, item => item === 2);
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .beforeOr(-1, item => item === 1);
  // -1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .beforeOr(() => -1, item => item === 1);
  // -1
}

beforeOrFail

beforeOrFail(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): 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: PredicateInvokable<TInput, ICollection<TInput>>

Returns TInput

Throws

ItemNotFoundCollectionError

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .beforeOrFail(item => item === 2);
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .beforeOrFail(item => item === 1);
// error is thrown
}

change

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

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

chunk

chunk(chunkSize: number): ICollection<ICollection<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 ICollection<ICollection<TInput>>
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection.apppend([1, 2, 3, 4, 5, 6, 7]);
  const chunks = collection.chunk(4);
  chunks.map(chunk => chunk.toArray()).toArray();
  // [[1, 2, 3, 4], [5, 6, 7]]
}
```
Implementation of ICollection.chunk
- Defined in src/collection/implementations/list-collection/list-collection.ts:631

chunkWhile

chunkWhile(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<ICollection<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: PredicateInvokable<TInput, ICollection<TInput>>
Returns ICollection<ICollection<TInput>>
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend("AABBCCCD")
    .chunkWhile((value, index, chunk) => {
      return value === chunk.last();
    })
    .map(chunk => chunk.toArray())
    .toArray();
  //  [["A", "A"], ["B", "B"], ["C", "C", "C"], ["D"]]
}
```
Implementation of ICollection.chunkWhile
- Defined in src/collection/implementations/list-collection/list-collection.ts:641

collapse

collapse(): ICollection<Collapse<TInput>>

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

Returns ICollection<Collapse<TInput>>

Example

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

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

count

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5, 6])
    .count(value => value % 2 === 0);
  // 3
}
```
Implementation of ICollection.count
- Defined in src/collection/implementations/list-collection/list-collection.ts:1142

countBy

countBy<TOutput = TInput>(
selectFn?: Map<TInput, ICollection<TInput>, TOutput>,
): ICollection<[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

selectFn: Map<TInput, ICollection<TInput>, TOutput> = ...

Returns ICollection<[TOutput, number]>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "a", "a", "b", "b", "c"])
    .countBy()
    .map(([key, collection]) => [key, .toArray()])
    .toArray();
  // [
  //  ["a", 3],
  //  ["b", 2],
  //  ["c", 1]
  // ]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["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: Iterable<TExtended, any, any>,
): ICollection<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: Iterable<TExtended, any, any>

Returns ICollection<CrossJoinResult<TInput, TExtended>>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2])
    .cross(["a", "b"])
    .toArray();
  // [
  //  [1, "a"],
  //  [1, "b"],
  //  [2, "a"],
  //  [2, "b"],
  // ]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([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: Iterable<TInput, any, any>,
selectFn?: Map<TInput, ICollection<TInput>, TOutput>,
): ICollection<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: Iterable<TInput, any, any>
selectFn: Map<TInput, ICollection<TInput>, TOutput> = ...

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 2, 3, 4, 5])
    .difference([2, 4, 6, 8])
    .toArray();
  // [1, 3, 5]
}

Example

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

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

// Assume the inputed collection is empty.
function main(collection: ICollection<Phone>): void {
  collection
    .apppend([
      { 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(): ICollection<[number, TInput]>
The entries returns an ICollection of key, value pairs for every entry in the collection.

Returns ICollection<[number, TInput]>
Implementation of ICollection.entries
- Defined in src/collection/implementations/list-collection/list-collection.ts:229

every

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([0, 1, 2, 3, 4, 5])
    .every(item => item < 6);
  // true
}
```
Implementation of ICollection.every
- Defined in src/collection/implementations/list-collection/list-collection.ts:528

filter

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3, 4, 5, 6])
    .filter(item => 2 < item && item < 5)
    .toArray();
  // [3, 4]
}
```
Implementation of ICollection.filter
- Defined in src/collection/implementations/list-collection/list-collection.ts:241

first

first<TOutput>(
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns null | TOutput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .first();
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .first(item => item > 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .first(item => item > 10);
  // null
}

// 3

firstOr

firstOr<TOutput, TExtended = TInput>(
defaultValue: Lazyable<TExtended>,
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: Lazyable<TExtended>
OptionalpredicateFn: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns TOutput | TExtended

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOr(-1);
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOr(-1, item => item > 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOr(-1, item => item > 10);
  // -1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOr(() => -1, item => item > 10);
  // -1
}

firstOrFail

firstOrFail<TOutput>(
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns TOutput

Throws

ItemNotFoundCollectionError

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOrFail();
  // 1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOrFail(item => item > 2);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .firstOrFail(item => item > 10);
  // throws an error
}

flatMap

flatMap<TOutput>(
mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput, any, any>>,
): ICollection<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: Map<TInput, ICollection<TInput>, Iterable<TOutput, any, any>>
Returns ICollection<TOutput>
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<string[]>): void {
  collection
    .append([["a", "b"], ["c", "d"]])
    .flatMap(item => [item.length, ...item])
    .toArray();
  // [2, "a", "b", 2, "c", "d"]
}
```
Implementation of ICollection.flatMap
- Defined in src/collection/implementations/list-collection/list-collection.ts:331

forEach

forEach(callback: ForEach<TInput, ICollection<TInput>>): void
The forEach method iterates through all items in the collection.
Parameters
- callback: ForEach<TInput, ICollection<TInput>>
Returns void
Implementation of ICollection.forEach
- Defined in src/collection/implementations/list-collection/list-collection.ts:1180

get

get(index: number): null | TInput

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

Parameters

index: number

Returns null | TInput

Example

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

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

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

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

getOrFail

getOrFail(index: number): TInput

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

Parameters

index: number

Returns TInput

Throws

ItemNotFoundCollectionError

Example

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

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

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

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

groupBy

groupBy<TOutput = TInput>(
selectFn?: Map<TInput, ICollection<TInput>, TOutput>,
): ICollection<[TOutput, ICollection<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

selectFn: Map<TInput, ICollection<TInput>, TOutput> = ...

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

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "a", "a", "b", "b", "c"])
    .groupBy()
    .map(([key, collection]) => [key, .toArray()])
    .toArray();
  // [
  //  [
  //    "a",
  //    ["a", "a", "a"]
  //  ],
  //  [
  //    "b",
  //    ["b", "b"]
  //  ],
  //  [
  //    "c",
  //    ["c"]
  //  ]
  // ]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
collection.apppend(["alice@gmail.com", "bob@yahoo.com", "carlos@gmail.com"]);
  const group = collection
    .groupBy(item => item.split("@")[1])
    .map(([key, collection]) => [key, .toArray()])
    .toArray();
  // [
  //   [
  //     "gmail.com",
  //     ["alice@gmail.com", "carlos@gmail.com"]
  //   ],
  //   [
  //     "yahoo.com",
  //     ["bob@yahoo.com"]
  //   ]
  // ]
}

insertAfter

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 2, 3, 4, 5])
    .insertAfter(item => item === 2, [-1, 20])
    .toArray();
  // [1, 2, -1, 20, 2, 3, 4, 5]
}
```
Implementation of ICollection.insertAfter
- Defined in src/collection/implementations/list-collection/list-collection.ts:888

insertBefore

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 2, 3, 4, 5])
    .insertBefore(item => item === 2, [-1, 20])
    .toArray();
  // [1, -1, 20, 2, 2, 3, 4, 5]
}
```
Implementation of ICollection.insertBefore
- Defined in src/collection/implementations/list-collection/list-collection.ts:873

isEmpty

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

Returns boolean
Implementation of ICollection.isEmpty
- Defined in src/collection/implementations/list-collection/list-collection.ts:1152

isNotEmpty

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

Returns boolean
Implementation of ICollection.isNotEmpty
- Defined in src/collection/implementations/list-collection/list-collection.ts:1156

join

join(separator?: string): 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 Extract<TInput, string>

Throws

Example

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

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

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

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

keys

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

Returns ICollection<number>
Implementation of ICollection.keys
- Defined in src/collection/implementations/list-collection/list-collection.ts:233

last

last<TOutput>(
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns null | TOutput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .last();
  // 4
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .last(item => item < 4);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .last(item => item > 10);
  // null
}

lastOr

lastOr<TOutput, TExtended = TInput>(
defaultValue: Lazyable<TExtended>,
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: Lazyable<TExtended>
OptionalpredicateFn: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns TOutput | TExtended

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOr(-1);
  // 4
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOr(-1, item => item < 4);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOr(-1, item => item > 10);
  // -1
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOr(() => -1, item => item > 10);
  // -1
}

lastOrFail

lastOrFail<TOutput>(
predicateFn?: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns TOutput

Throws

ItemNotFoundCollectionError

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOrFail();
  // 4
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .lastOrFail(item => item < 4);
  // 3
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .lastOrFail(item => item > 10);
    .apppend([1, 2, 3, 4])
  // throws an error
}

map

map<TOutput>(
mapFn: Map<TInput, ICollection<TInput>, TOutput>,
): ICollection<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: Map<TInput, ICollection<TInput>, TOutput>
Returns ICollection<TOutput>
Example
```
import type { ICollection } from "@daiso-tech/core";

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

max

max(): 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. If the collection is empty an error will also be thrown.

Returns Extract<TInput, number>
Throws
TypeCollectionError

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3])
    .max();
  // 3
}
```
Implementation of ICollection.max
- Defined in src/collection/implementations/list-collection/list-collection.ts:487

median

median(): 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. If the collection is empty an error will also be thrown.

Returns Extract<TInput, number>
Throws
TypeCollectionError

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3])
    .median();
  // 2
}
```
Implementation of ICollection.median
- Defined in src/collection/implementations/list-collection/list-collection.ts:435

min

min(): 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. If the collection is empty an error will also be thrown.

Returns Extract<TInput, number>
Throws
TypeCollectionError

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3])
    .min();
  // 1
}
```
Implementation of ICollection.min
- Defined in src/collection/implementations/list-collection/list-collection.ts:465

nth

nth(step: number): ICollection<TInput>

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

Parameters

step: number

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .nth(4)
    .toArray();
  // ["a", "e"]
}

padEnd

padEnd<TExtended = TInput>(
maxLength: number,
fillItems: Iterable<TExtended, any, any>,
): ICollection<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: Iterable<TExtended, any, any>

Returns ICollection<TInput | TExtended>

Example

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

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

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .append("abc")
    .padEnd(6, "123465")
    .join("");
  // "abc123"
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .append("abc")
    .padEnd(8, "0")
    .join("");
  // "abc00000"

}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .append("abc")
    .padEnd(1, "_")
    .join("");
  // "abc"
}

padStart

padStart<TExtended = TInput>(
maxLength: number,
fillItems: Iterable<TExtended, any, any>,
): ICollection<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: Iterable<TExtended, any, any>

Returns ICollection<TInput | TExtended>

Example

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

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

Example

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

Example

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

Example

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

page

page(page: number, pageSize: number): ICollection<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 ICollection<TInput>
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3, 4, 5, 6, 7, 8, 9])
    .page(2, 3)
    .toArray()
  // [4, 5, 6]
}
```
Implementation of ICollection.page
- Defined in src/collection/implementations/list-collection/list-collection.ts:397

partition

partition(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<ICollection<TInput>>

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

Parameters

predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns ICollection<ICollection<TInput>>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5, 6])
    .partition(item => item < 3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [3, 4, 5, 6]]
}

percentage

percentage(predicateFn: PredicateInvokable<TInput, ICollection<TInput>>): number
The percentage method may be used to quickly determine the percentage of items in the collection that pass predicateFn. If the collection is empty an error will also be thrown.
Parameters
- predicateFn: PredicateInvokable<TInput, ICollection<TInput>>
Returns number
Throws
EmptyCollectionError
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 1, 2, 2, 2, 3])
    .percentage(value => value === 1);
  // 33.333
}
```
Implementation of ICollection.percentage
- Defined in src/collection/implementations/list-collection/list-collection.ts:509

pipe

pipe<TOutput = TInput>(
callback: Transform<ICollection<TInput>, TOutput>,
): 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: Transform<ICollection<TInput>, TOutput>

Returns TOutput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  function toNbrs<TInput>(
    collection: ICollection<TInput>,
  ): ICollection<number> {
    return collection
      .map((item) => Number(item))
      .reject((nbr) => Number.isNaN(nbr));
  }

  function nbrToStr(collection: ICollection<number>): number[] {
    return collection.repeat(2).toArray();
  }

  const piped = collection
    .apppend([1, "2", "a", 1, 3, {}])
    .pipe(toNbrs)
    .pipe(nbrToStr);
  // [ 1, 2, 1, 3 ]
}

prepend

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5])
    .prepend([-1, 20])
    .toArray();
  // [-1, 20, 1, 2, 3, 4, 5]
}
```
Implementation of ICollection.prepend
- Defined in src/collection/implementations/list-collection/list-collection.ts:861

reduce

reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>): 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: Reduce<TInput, ICollection<TInput>, TInput>

Returns TInput

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3]);
    .reduce((sum, item) => sum + item);
  // 6
}

Example

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

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

reduce(
reduceFn: Reduce<TInput, ICollection<TInput>, TInput>,
initialValue: TInput,
): TInput
Parameters
- reduceFn: Reduce<TInput, ICollection<TInput>, TInput>
- initialValue: TInput
Returns TInput
Implementation of ICollection.reduce
- Defined in src/collection/implementations/list-collection/list-collection.ts:273
reduce<TOutput>(
reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>,
initialValue: TOutput,
): TOutput
Type Parameters
- TOutput
Parameters
- reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>
- initialValue: TOutput
Returns TOutput
Implementation of ICollection.reduce
- Defined in src/collection/implementations/list-collection/list-collection.ts:278

reject

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3, 4, 5, 6])
    .reject(item => 2 < item && item < 5)
    .toArray();
  // [1, 2, 5, 6]
}
```
Implementation of ICollection.reject
- Defined in src/collection/implementations/list-collection/list-collection.ts:251

repeat

repeat(amount: number): ICollection<TInput>

The repeat method will repeat the original collection amount times.

Parameters

amount: number

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3])
    .repeat(3)
    .toArray();
  // [1, 2, 3,  1, 2, 3,  1, 2, 3]
}

reverse

reverse(_chunkSize?: number): ICollection<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
- Optional_chunkSize: number
Returns ICollection<TInput>
Example
```
import type { ICollection } from "@daiso-tech/core";

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([-1, 2, 4, 3])
    .reverse()
    .toArray();
  // [3, 4, 2, -1]
}
```
Implementation of ICollection.reverse
- Defined in src/collection/implementations/list-collection/list-collection.ts:960

searchFirst

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "b", "c"])
    .searchFirst(item => item === "b");
  // 1
}
```
Implementation of ICollection.searchFirst
- Defined in src/collection/implementations/list-collection/list-collection.ts:1160

searchLast

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "b", "c"])
    .searchLast(item => item === "b");
  // 2
}
```
Implementation of ICollection.searchLast
- Defined in src/collection/implementations/list-collection/list-collection.ts:1168

serialize

serialize(): TInput[]
Returns TInput[]
Implementation of ICollection.serialize
- Defined in src/collection/implementations/list-collection/list-collection.ts:217

set

set(
index: number,
value: TInput | Map<TInput, ICollection<TInput>, TInput>,
): ICollection<TInput>

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

Parameters

index: number
value: TInput | Map<TInput, ICollection<TInput>, TInput>

Returns ICollection<TInput>

Example

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

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

Example

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

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

shuffle

shuffle(mathRandom?: () => number): ICollection<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 ICollection<TInput>
Implementation of ICollection.shuffle
- Defined in src/collection/implementations/list-collection/list-collection.ts:964

size

size(): number
The size returns the size of the collection.

Returns number
Implementation of ICollection.size
- Defined in src/collection/implementations/list-collection/list-collection.ts:1148

skip

skip(offset: number): ICollection<TInput>

The skip method skips the first offset items.

Parameters

offset: number

Returns ICollection<TInput>

Example

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

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

skipUntil

skipUntil(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<TInput>

The skipUntil method skips items until predicateFn returns true.

Parameters

predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .skipUntil(item => item >= 3)
    .toArray();
  // [3, 4]
}

skipWhile

skipWhile(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<TInput>

The skipWhile method skips items until predicateFn returns false.

Parameters

predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4])
    .skipWhile(item => item <= 3)
    .toArray();
  // [4]
}

slice

slice(start?: number, end?: number): ICollection<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 ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(3)
    .toArray();
  // ["d", "e", "f"]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(undefined, 2)
    .toArray()
  // ["a", "b"]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(2, 5)
    .toArray()
  // ["c", "d", "e"]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(-2)
    .toArray();
  // ["e", "f"]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(undefined, -2)
    .toArray()
  // ["a", "b", "c", "d"]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["a", "b", "c", "d", "e", "f"])
    .slice(-4, -2)
    .toArray();
  // ["c", "d"]
}

sliding

sliding(chunkSize: number, step?: number): ICollection<ICollection<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 ICollection<ICollection<TInput>>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5])
    .sliding(2)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [2, 3], [3, 4], [4, 5]]
}

sole

sole<TOutput>(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>, TOutput>,
): 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: PredicateInvokable<TInput, ICollection<TInput>, TOutput>

Returns TOutput

Throws

ItemNotFoundCollectionError

Throws

MultipleItemsFoundCollectionError

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5])
    .sole(item => item === 4);
  // 4
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 4, 5])
    .sole(item => item === 4);
  // error is thrown
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 5])
    .sole(item => item === 4);
  // error is thrown
}

some

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([0, 1, 2, 3, 4, 5])
    .some(item => item === 1);
  // true
}
```
Implementation of ICollection.some
- Defined in src/collection/implementations/list-collection/list-collection.ts:520

sort

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

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

Parameters

Optionalcomparator: Comparator<TInput>

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([-1, 2, 4, 3])
    .sort()
    .toArray()
  // [-1, 2, 3, 4]
}

Example

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

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

// Assume the inputed collection is empty.
function main(collection: ICollection<Person>): void {
  collection
    .apppend([
      { 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): ICollection<ICollection<TInput>>

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

Parameters

chunkAmount: number

Returns ICollection<ICollection<TInput>>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2], [3, 4], [5]]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5, 6])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray()
  // [[1, 2], [3, 4], [5, 6]]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 2, 3, 4, 5, 6, 7])
    .split(3)
    .map(chunk => chunk.toArray())
    .toArray();
  // [[1, 2, 7], [3, 4], [5, 6]]
}

sum

sum(): 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. If the collection is empty an error will also be thrown.

Returns Extract<TInput, number>
Throws
TypeCollectionError

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .append([1, 2, 3])
    .sum();
  // 6
}
```
Implementation of ICollection.sum
- Defined in src/collection/implementations/list-collection/list-collection.ts:404

take

take(limit: number): ICollection<TInput>

The take method takes the first limit items.

Parameters

limit: number

Returns ICollection<TInput>

Example

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

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

Example

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

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

takeUntil

takeUntil(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<TInput>

The takeUntil method takes items until predicateFn returns true.

Parameters

predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns ICollection<TInput>

Example

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

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

takeWhile

takeWhile(
predicateFn: PredicateInvokable<TInput, ICollection<TInput>>,
): ICollection<TInput>

The takeWhile method takes items until predicateFn returns false.

Parameters

predicateFn: PredicateInvokable<TInput, ICollection<TInput>>

Returns ICollection<TInput>

Example

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

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

tap

tap(callback: Tap<ICollection<TInput>>): ICollection<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<ICollection<TInput>>

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection.apppend([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(): TInput[]
The toArray method converts the collection to a new Array | Array.

Returns TInput[]
Implementation of ICollection.toArray
- Defined in src/collection/implementations/list-collection/list-collection.ts:1186

toIterator

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

Returns Iterator<TInput, void, any>
Implementation of ICollection.toIterator
- Defined in src/collection/implementations/list-collection/list-collection.ts:225

toMap

toMap(): 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 EnsureMap<TInput>
Throws
TypeCollectionError
Implementation of ICollection.toMap
- Defined in src/collection/implementations/list-collection/list-collection.ts:1220

toRecord

toRecord(): 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 EnsureRecord<TInput>
Throws
TypeCollectionError
Implementation of ICollection.toRecord
- Defined in src/collection/implementations/list-collection/list-collection.ts:1190

unique

unique<TOutput = TInput>(
selectFn?: Map<TInput, ICollection<TInput>, TOutput>,
): ICollection<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

selectFn: Map<TInput, ICollection<TInput>, TOutput> = ...

Returns ICollection<TInput>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1, 1, 2, 2, 3, 4, 2])
    .unique()
    .toArray();
  // [1, 2, 3, 4]
}

Example

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

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

// Assume the inputed collection is empty.
function main(collection: ICollection<Phone>): void {
  collection
    .apppend([
      { 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(): ICollection<TInput>
The values method returns a copy of the collection.

Returns ICollection<TInput>
Implementation of ICollection.values
- Defined in src/collection/implementations/list-collection/list-collection.ts:237

when

when<TExtended = TInput>(
condition: boolean,
callback: Modifier<ICollection<TInput>, ICollection<TExtended>>,
): ICollection<TInput | TExtended>

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

Type Parameters

TExtended = TInput

Parameters

condition: boolean
callback: Modifier<ICollection<TInput>, ICollection<TExtended>>

Returns ICollection<TInput | TExtended>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([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: Modifier<ICollection<TInput>, ICollection<TExtended>>,
): ICollection<TInput | TExtended>

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

Type Parameters

TExtended = TInput

Parameters

callback: Modifier<ICollection<TInput>, ICollection<TExtended>>

Returns ICollection<TInput | TExtended>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([])
    .whenEmpty(collection => collection.append([-3]))
    .toArray();
  // [-3]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection
    .apppend([1])
    .whenEmpty(collection => collection.append([-3]))
    .toArray();
  // [1]
}

whenNot

whenNot<TExtended = TInput>(
condition: boolean,
callback: Modifier<ICollection<TInput>, ICollection<TExtended>>,
): ICollection<TInput | TExtended>

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

Type Parameters

TExtended = TInput

Parameters

condition: boolean
callback: Modifier<ICollection<TInput>, ICollection<TExtended>>

Returns ICollection<TInput | TExtended>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection.apppend([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: Modifier<ICollection<TInput>, ICollection<TExtended>>,
): ICollection<TInput | TExtended>

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

Type Parameters

TExtended = TInput

Parameters

callback: Modifier<ICollection<TInput>, ICollection<TExtended>>

Returns ICollection<TInput | TExtended>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection.apppend([])
    .whenNotEmpty(collection => collection.append([-3]))
    .toArray();
  // []
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<number>): void {
  collection = collection
    .apppend([1])
    .whenNotEmpty(collection => collection.append([-3]))
    .toArray();
  // [1, -3]
}

zip

zip<TExtended>(
iterable: Iterable<TExtended, any, any>,
): ICollection<[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: Iterable<TExtended, any, any>

Returns ICollection<[TInput, TExtended]>

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["Chair", "Desk"]);
    .zip([100, 200]);
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["Chair", "Desk", "Couch"])
    .zip([100, 200])
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

Example

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

// Assume the inputed collection is empty.
function main(collection: ICollection<string>): void {
  collection
    .apppend(["Chair", "Desk"])
    .zip([100, 200, 300])
    .toArray();
  // [["Chair", 100], ["Desk", 200]]
}

`Static`concat

concat<TValue>(
iterables: Iterable<Iterable<TValue, any, any>, any, any>,
): ICollection<TValue>

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

Type Parameters

TValue

Parameters

iterables: Iterable<Iterable<TValue, any, any>, any, any>

Returns ICollection<TValue>

Example

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

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

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

`Static`deserialize

deserialize<TInput>(serializedValue: TInput[]): ICollection<TInput>
Type Parameters
- TInput
Parameters
- serializedValue: TInput[]
Returns ICollection<TInput>
- Defined in src/collection/implementations/list-collection/list-collection.ts:157

`Static`difference

difference<TValue, TSelect>(
    iterableA: Iterable<TValue, any, any>,
    iterableB: Iterable<TValue, any, any>,
    selectFn?: Map<TValue, ICollection<TValue>, TSelect>,
): ICollection<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: Iterable<TValue, any, any>
iterableB: Iterable<TValue, any, any>
OptionalselectFn: Map<TValue, ICollection<TValue>, TSelect>

Returns ICollection<TValue>

Example

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

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

Example

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

const collection = ListCollection.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
);
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: Iterable<TValueA, any, any>,
iterableB: Iterable<TValueB, any, any>,
): ICollection<[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: Iterable<TValueA, any, any>
iterableB: Iterable<TValueB, any, any>

Returns ICollection<[TValueA, TValueB]>

Example

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

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

Example

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

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

Example

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

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

Class ListCollection<TInput>

Type Parameters

Implements

Index

Constructors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns ListCollection<TInput>

Example

Example

Example

Example

Example

Methods

[iterator]

Returns Iterator<TInput, any, any>

after

Parameters

Returns null | TInput

Example

Example

afterOr

Type Parameters

Parameters

Returns TInput | TExtended

Example

Example

Example

afterOrFail

Parameters

Returns TInput

Throws

Example

Example

append

Type Parameters

Parameters

Returns ICollection<TInput | TExtended>

Example

average

Returns Extract<TInput, number>

Throws

Throws

Example

before

Parameters

Returns null | TInput

Example

Example

beforeOr

Type Parameters

Parameters

Returns TInput | TExtended

Example

Example

Example

beforeOrFail

Parameters

Returns TInput

Throws

Example

Example

change

Type Parameters

Parameters

Returns ICollection<TInput | TFilterOutput | TMapOutput>

Example

chunk

Parameters

Returns ICollection<ICollection<TInput>>

Example

chunkWhile

Parameters

Returns ICollection<ICollection<TInput>>

Example

collapse

Returns ICollection<Collapse<TInput>>