Class Stream<T>`Abstract`

A stream is an iterable, lazy sequence of elements.

Type Parameters

T
the type of the elements within the stream

Implements

Iterable<T>

Methods

`Static`allIntegers

allIntegers(start?: number): Stream<number>
Generates an infinite stream of integers, starting with start (which defaults to 0). In other words, this produces the interval [start, start + 1, ...). The returned stream is infinite, truncate the stream accordingly by using for example take(), or break in a for...of loop.
Parameters
- Optionalstart: number
 the start value
Returns Stream<number>
Example
```
import { Stream } from "apprt-streams/Stream";
const numbers = Stream.allIntegers().take(3).toArray(); // [0, 1, 2]
```
- Defined in Stream.ts:200

`Static`concat

concat<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<ConcatValue<Ts>>
Creates a new stream by chaining the given iterables after each other.
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 the iterables to concatenate
Returns Stream<ConcatValue<Ts>>
Example
```
import { Stream } from "apprt-streams/Stream";
const result = Stream.concat([1], [2]).toArray(); // [1, 2]
```
- Defined in Stream.ts:215

`Static`empty

empty(): Stream
Creates a new, empty stream.
Type Parameters
- U = any
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";
Stream.empty().count(); // 0
```
- Defined in Stream.ts:53

`Static`entries

entries<K extends string, U>(object: Record<K, U>): Stream<[key: K, value: U]>

Creates a stream that iterates over the [key, value] pairs of the given object.

Type Parameters

K extends string
U

Parameters

object: Record<K, U>

Returns Stream<[key: K, value: U]>

Example

import { Stream } from "apprt-streams/Stream";
const input = { a: 1, b: 2};
const output = Stream.entries(input).map((e) => `${e[0]}${e[1]}`).toArray(); // ["a1", "b2"] (order might differ)

`Static`enumerate

enumerate(iterable: Iterable): Stream<[index: number, value: U]>
Generates [index, value] tuples where value is from the original iterable and index is the index of the current value.
Type Parameters
- U
Parameters
- iterable: Iterable
Returns Stream<[index: number, value: U]>
Example
```
import { Stream } from "apprt-streams/Stream";

const result = Stream.enumerate(["a", "b"]).toArray(); // [[0, "a"], [1, "b"]]
```
- Defined in Stream.ts:76

`Static`from

from(iterable: Iterable): Stream
Wraps an iterable into a stream.

The returned stream can be iterated multiple times if the original iterable can also be iterated multiple times (some iterables, like generators, do not support repeated iteration).
Type Parameters
- U
Parameters
- iterable: Iterable
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";
Stream.from([]); // Wraps any iterable
Stream.from(Stream.empty()); // Returns original stream for stream arguments
```
- Defined in Stream.ts:32
from(iterable: undefined | null | Iterable): Stream
Wraps an iterable into a stream.

The returned stream can be iterated multiple times if the original iterable can also be iterated multiple times (some iterables, like generators, do not support repeated iteration).
Type Parameters
- U
Parameters
- iterable: undefined | null | Iterable
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";
Stream.from([]); // Wraps any iterable
Stream.from(Stream.empty()); // Returns original stream for stream arguments
```
- Defined in Stream.ts:33

`Static`generate

generate(supplier: () => U): Stream
Generates a stream by repeatedly invoking the provided supplier function. The returned stream is infinite, truncate the stream accordingly by using for example take(), or break in a for...of loop.
Type Parameters
- U
Parameters
- supplier: () => U
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";

let nextValue = 1;
function generateNumbers() {
 return nextValue++;
}

const items = Stream.generate(generateNumbers).take(4).toArray(); // [1, 2, 3, 4]
```
- Defined in Stream.ts:97

`Static`integers

integers(count: number): Stream<number>
Generates a stream of count integers, starting with 0. In other words, this produces the interval [0, 1, ..., count).
Parameters
- count: number
 the number of integers to produce
Returns Stream<number>
Example
```
import { Stream } from "apprt-streams/Stream";
const numbers = Stream.integers(3).toArray(); // [0, 1, 2]
```
- Defined in Stream.ts:155
integers(start: number, count: number): Stream<number>
Generates a stream of count integers, starting with the provided start index. In other words, this produces the interval [start +0, start +1, ..., start +count).
Parameters
- start: number
 the start value
- count: number
 the number of integers to produce
Returns Stream<number>
Example
```
import { Stream } from "apprt-streams/Stream";
const numbers = Stream.integers(3, 4).toArray(); // [3, 4, 5, 6]
```
- Defined in Stream.ts:170

`Static`keys

keys<K extends string, U>(object: Record<K, U>): Stream<K>

Creates a stream that iterates over the keys of the given object.

Type Parameters

K extends string
U

Parameters

object: Record<K, U>

Returns Stream<K>

Example

import { Stream } from "apprt-streams/Stream";
const input = { a: 1, b: 2};
const output = Stream.keys(input).map((k) => k + k).toArray(); // ["aa", "bb"] (order might differ)

`Static`of

of(...items: U[]): Stream
Creates a stream from the given items.
Type Parameters
- U
Parameters
- ...items: U[]
Returns Stream
- Defined in Stream.ts:61

`Static`values

values<K extends string, U>(object: Record<K, U>): Stream

Creates a stream that iterates over the values of the given object.

Type Parameters

K extends string
U

Parameters

object: Record<K, U>

Returns Stream

Example

import { Stream } from "apprt-streams/Stream";
const input = { a: 1, b: 2};
const output = Stream.values(input).map((v) => v * 2).toArray(); // [2, 4] (order might differ)

`Static`zip

zip<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<MapIterableValues<Ts>>
Creates a new stream by zipping the elements of the given iterables. The iterables will be iterated in parallel, so each element of the new stream will be a tuple with one element per iterable.

The stream stops when the shortest of the given iterables has ended.
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 the iterables to concatenate
Returns Stream<MapIterableValues<Ts>>
Example
```
import { Stream } from "apprt-streams/Stream";
const left = [1, 2];
const right = ["a", "b", "c"];
const zipped = Stream.zip(left, right).toArray(); // [[1, "a"], [2, "b"]]
```
- Defined in Stream.ts:235

`Static`zipLongest

zipLongest<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<ZipLongestValue<Ts>>
Creates a new stream by zipping the elements of the given iterables. The iterables will be iterated in parallel, so each element of the new stream will be a tuple with one element per iterable.

The stream stops when the longest of the given iterables has ended. When individual iterables are exhausted, their tuple items are set to undefined.
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 the iterables to zip
Returns Stream<ZipLongestValue<Ts>>
Example
```
import { Stream } from "apprt-streams/Stream";
const left = [1, 2];
const right = ["a", "b", "c"];
const zipped = Stream.zipLongest(left, right).toArray(); // [[1, "a"], [2, "b"], [undefined, "c"]]
```
- Defined in Stream.ts:256

`Abstract`[iterator]

"[iterator]"(): Iterator<T>
Allows iteration in for...of loops.

Returns Iterator<T>
Example
```
for (const value of Stream.integers(5)) {
 console.info(value);
}
```
Implementation of Iterable.[iterator]
- Defined in Stream.ts:1000

chunk

chunk(chunkSize: number): Stream<T[]>
Returns a stream over the original items grouped into chunks of size chunkSize. Up to chunkSize consecutive elements will be gathered into an array and then returned by the stream.

All arrays, except for the last one, will be of length chunkSize.
Parameters
- chunkSize: number
 the maximum chunk size
Returns Stream<T[]>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2, 3, 4, 5];
const chunked = Stream.from(items).chunk(3).toArray(); // [[1, 2, 3], [4, 5]]
```
- Defined in Stream.ts:465

concatWith

concatWith<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<ConcatValue<[Stream<T>, ...Ts[]]>>
Chains the given iterables after this (see static concat function for details).
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 the iterables to concatenate
Returns Stream<ConcatValue<[Stream<T>, ...Ts[]]>>
- Defined in Stream.ts:475

count

count(): number
Returns the number of elements in this stream.

NOTE: this will iterate over the entire stream!

Returns number
- Defined in Stream.ts:813

cycle

cycle(): Stream<T>
Returns a stream that repeats the elements of this stream. The returned stream is infinite, truncate the stream accordingly by using for example take(), or break in a for...of loop.

Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2];
const cycled = Stream.from(items).cycle().take(5).toArray(); // [1, 2, 1, 2, 1]
```
- Defined in Stream.ts:445

enumerate

enumerate(): Stream<[index: number, value: T]>
Generates [index, value] tuples where value is from the original iterable and index is the index of the current value.

Returns Stream<[index: number, value: T]>
See
Stream.enumerate
- Defined in Stream.ts:266

every

every(predicate: (item: T) => boolean): boolean
Determines if all items in the stream fulfill the given predicate.

NOTE: Trivially returns true if the stream is empty.
Parameters
- predicate: (item: T) => boolean
  Returns true if all item in the stream fulfills the given predicate, false otherwise.
Returns boolean
- Defined in Stream.ts:697

filter

filter(predicate: (item: T) => item is U): Stream
Returns a stream that filters the input by predicate. Only items for which predicate(item) returns true will be produced by the stream.
Type Parameters
- U
Parameters
- predicate: (item: T) => item is U
 A function that returns true if the item should be part of the returned stream.
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, -2, 3];
const result = Stream.from(items).filter(n => n > 0).toArray(); // [1, 3]
```
- Defined in Stream.ts:284
filter(predicate: (item: T) => boolean): Stream<T>
Returns a stream that filters the input by predicate. Only items for which predicate(item) returns true will be produced by the stream.
Parameters
- predicate: (item: T) => boolean
 A function that returns true if the item should be part of the returned stream.
Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, -2, 3];
const result = Stream.from(items).filter(n => n > 0).toArray(); // [1, 3]
```
- Defined in Stream.ts:285

filterMap

filterMap(
transform: (item: T) => undefined | null | U,
): Stream<NonNullable>
Returns a stream that transforms all items using the given transform function and then discards all items that are null or undefined.
Type Parameters
- U
Parameters
- transform: (item: T) => undefined | null | U
 A function that maps each item to a nullable item of an arbitrary type. Return values null and undefined will not be included in the returned stream.
Returns Stream<NonNullable>
Example
```
import { Stream } from "apprt-streams/Stream";
const persons = [{ age: 7 }, { age: 18 }, { age: 21 }];
const adultAges = Stream.from(persons).filterMap(
 (person) => person.age >= 18 ? person.age : undefined
).toArray(); // [18, 21]
```
- Defined in Stream.ts:324

find

find(predicate: (item: T) => item is U): U
Searches the elements in this stream for an item for which the predicate returns true. Returns the item on success or undefined if no item was found.
Type Parameters
- U
Parameters
- predicate: (item: T) => item is U
Returns U
- Defined in Stream.ts:723
find(predicate: (item: T) => boolean): undefined | T
Searches the elements in this stream for an item for which the predicate returns true. Returns the item on success or undefined if no item was found.
Parameters
- predicate: (item: T) => boolean
Returns undefined | T
- Defined in Stream.ts:724

first

first(): undefined | T
Returns the first item in this stream, or undefined if the stream is empty.

Returns undefined | T
- Defined in Stream.ts:652

flat

flat(): Stream<FlatValue<T>>
Returns a stream that flattens its input by one layer (elements that are iterable become multiple elements of the new stream).

Returns Stream<FlatValue<T>>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [[1], [2, 3]];
const result = Stream.from(items).flat().toArray(); // [1, 2, 3]
```
- Defined in Stream.ts:339

forEach

forEach(callback: (item: T, index: number) => void): void
Invokes the callback for every item in the stream. Works exactly like Array's forEach function, with the exception that no source array is passed.
Parameters
- callback: (item: T, index: number) => void
Returns void
- Defined in Stream.ts:738

groupAdjacent

groupAdjacent(predicate: (left: T, right: T) => boolean): Stream<T[]>
Returns a stream that groups adjacent elements for which the predicate returns true into arrays.

This is different from groupBy because it allows arbitrary conditions for grouping. However, only elements next to each other can belong to a group. A new group is started whenever an element is encountered that does not belong to the current group.
Parameters
- predicate: (left: T, right: T) => boolean
 A function that returns true if left and right belong to the same group.
Returns Stream<T[]>
Example
```
const numbers = [1, 2, 4, 3, 0];
const grouped = Stream.from(numbers)
 .groupAdjacent((l, r) => Math.abs(l - r) <= 1) // close items belong to the same group
 .toArray(); // [[1, 2], [4, 3], [0]]
```
- Defined in Stream.ts:550

groupBy

groupBy(keyFunc: (item: T) => U): Stream<[U, T[]]>
Groups items together for which keyFunc returns the same value. The keyFunc function should generate keys that are supported by JavaScript's Map type.

NOTE: This function reads the entire stream into memory and stores items in an internal map, which may be inefficient for very large datasets.
Type Parameters
- U
Parameters
- keyFunc: (item: T) => U
 Given an item from the stream, returns a group key for that item. All items with an equal group key end up in the same group.
Returns Stream<[U, T[]]>
Example
```
import { Stream } from "apprt-streams/Stream";
const persons = [
 { name: "A", age: 18 },
 { name: "B", age: 18 },
 { name: "C", age: 20 },
];
const byAge = Stream.from(persons)
 .groupBy((p) => p.age)
 .toObject(); // { 18: [person A, person B], 20: [person C] }
```
- Defined in Stream.ts:528

includes

includes(item: T): boolean
Returns true if this stream contains an element that compares equal to item. Comparisons use strict equality (===).
Parameters
- item: T
Returns boolean
- Defined in Stream.ts:710

isEmpty

isEmpty(): boolean
Returns true if there is at least one element in this stream, false otherwise.

Returns boolean
- Defined in Stream.ts:825

join

join(separator?: string): string
Joins all elements of this stream together into a string. Individual elements will be converted to string (via String(elements)) and separated by separator.
Parameters
- separator: string = ","
  The separator to use between two elements. Defaults to ",".
Returns string
- Defined in Stream.ts:796

last

last(): undefined | T
Returns the last item in this stream, or undefined if this stream is empty.

NOTE: This iterates over the entire stream in order to find the last element. Be aware of the performance implications: the function should not be called repeatedly (cache the result instead) and you should ensure that your stream is finite.

Returns undefined | T
- Defined in Stream.ts:666

map

map(transform: (item: T) => U): Stream
Returns a stream that maps all elements of the input by using the provided transform function.
Type Parameters
- U
Parameters
- transform: (item: T) => U
 A function that maps each item to a another item of an arbitrary type.
Returns Stream
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2];
const result = Stream.from(items).map(n => n + 1).toArray(); // [2, 3]
```
- Defined in Stream.ts:303

max

max(compareFunc?: (left: T, right: T) => number): undefined | T
Returns the largest stream item according to the given compareFunc. If multiple candidates for the largest element compare equal to each other, the first of those items (according to the stream order) will be returned.
Parameters
- OptionalcompareFunc: (left: T, right: T) => number
 Given two items left and right, returns < 0 if left < right, > 0 if left > right and 0 otherwise. When not specified, items are compared using standard < and > (which might be useless, e.g. when items are objects or arrays).
Returns undefined | T
the largest item or undefined if the stream is empty.
- Defined in Stream.ts:846

maxBy

maxBy(
keyFunc: (value: T) => U,
compareFunc?: (left: U, right: U) => number,
): undefined | T
Like max(), but compares keys derived from the stream's items instead of the items themselves. The item with the largest key will be returned (or undefined if the stream is empty).
Type Parameters
- U
Parameters
- keyFunc: (value: T) => U
 Given an item, returns a sort key for comparison during sorting. This function should be fast, because it will be invoked at least once for every element.
- OptionalcompareFunc: (left: U, right: U) => number
 Given two keys derived by keyFunc, returns < 0 if left < right, > 0 if left > right and 0 otherwise. When not specified, keys are compared using standard < and > (which might be useless, e.g. when keys are objects or arrays).
Returns undefined | T
the largest item or undefined if the stream is empty.
- Defined in Stream.ts:872

min

min(compareFunc?: (left: T, right: T) => number): undefined | T
Like max, but returns the smallest item instead.
Parameters
- OptionalcompareFunc: (left: T, right: T) => number
Returns undefined | T
- Defined in Stream.ts:853

minBy

minBy(
keyFunc: (value: T) => U,
compareFunc?: (left: U, right: U) => number,
): undefined | T
Like maxBy, but returns the item with the smallest key instead.
Type Parameters
- U
Parameters
- keyFunc: (value: T) => U
- OptionalcompareFunc: (left: U, right: U) => number
Returns undefined | T
- Defined in Stream.ts:905

reduce

reduce(reduceFunc: (currentValue: T, item: T, index: number) => T): T
Invokes the reduceFunc for every element of the stream in order to provide a single return value. Works exactly like Array's reduce function, with the exception that no source array is passed.
Parameters
- reduceFunc: (currentValue: T, item: T, index: number) => T
Returns T
- Defined in Stream.ts:750
reduce(
reduceFunc: (currentValue: U, item: T, index: number) => U,
initial: U,
): U
Invokes the reduceFunc for every element of the stream in order to provide a single return value. Works exactly like Array's reduce function, with the exception that no source array is passed.
Type Parameters
- U
Parameters
- reduceFunc: (currentValue: U, item: T, index: number) => U
- initial: U
Returns U
- Defined in Stream.ts:751

repeat

repeat(count: number): Stream<T>

Returns a stream that repeats its contents count times.

Parameters

count: number
the number of repetitions

Returns Stream<T>

Example

import { Stream } from "apprt-streams/Stream";
const items = ["a", "b"];
const repeated = Stream.from(items).repeat(2).toArray(); // ["a", "b", "a", "b"];

reverse

reverse(): Stream<T>
Returns a stream that consists of all elements of this stream, in reversed order.

NOTE: This function reads the entire stream into memory in order to reverse the item order. This may be inefficient for very large datasets.

Returns Stream<T>
Example
```
const items = Stream.integers(4).reverse().toArray(); // [3, 2, 1, 0]
```
- Defined in Stream.ts:645

skip

skip(count: number): Stream<T>
Returns a stream that skips the first count elements of its input.
Parameters
- count: number
 the number of items to skip
Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2, 3];
const result = Stream.from(items).skip(1).toArray(); // [2, 3]
```
- Defined in Stream.ts:355

skipWhile

skipWhile(predicate: (item: T) => boolean): Stream<T>
Returns a stream that skips elements while the predicate returns true. Once the predicate returns false, all the following items will be included in the returned stream.
Parameters
- predicate: (item: T) => boolean
 A predicate determining if items shall be skipped. Once the predicate returns false, all remaining items are included in the returned stream.
Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2, 3, 4, -1, -2, -3];
const result = Stream.from(items).skipWhile((n) => n < 4).toArray(); // [4, -1, -2, -3]
```
- Defined in Stream.ts:376

some

some(predicate: (item: T) => boolean): boolean
Determines if the given condition matches to at least one of the stream's items.
Parameters
- predicate: (item: T) => boolean
  Returns true if any item in the stream fulfills the given predicate, false otherwise.
Returns boolean
- Defined in Stream.ts:680

sort

sort(compareFunc?: (left: T, right: T) => number): Stream<T>
Returns a stream that has all its elements sorted according to the given compareFunc. The comparison function is optional, the Array sort behavior will be used by default when the function is omitted. The function must behave as expected by the Array.sort() method.

See also: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

NOTE: This function reads the entire stream into memory and stores all elements in an array to be able to sort it. This may be inefficient for very large datasets.
Parameters
- OptionalcompareFunc: (left: T, right: T) => number
 Given two elements left and right, returns < 0 if left < right, > 0 if right > left and 0 otherwise. When not specified, elements are compared using standard < and > (which might be useless, e.g. when keys are objects or arrays).
Returns Stream<T>
- Defined in Stream.ts:570

sortBy

sortBy(
keyFunc: (item: T) => U,
compareFunc?: (leftKey: U, rightKey: U) => number,
): Stream<T>
Like sort(), but sorts by comparing keys derived from the stream's items.

NOTE: This function reads the entire stream into memory and stores all elements in an array to be able to sort it. This may be inefficient for very large datasets.
Type Parameters
- U
Parameters
- keyFunc: (item: T) => U
 Given an item, returns a sort key for comparison during sorting. This function should be fast, because it will be invoked at least once for every element.
- OptionalcompareFunc: (leftKey: U, rightKey: U) => number
 Given two keys derived by keyFunc, returns < 0 if left < right, > 0 if right > left and 0 otherwise. When not specified, keys are compared using standard < and > (which might be useless, e.g. when keys are objects or arrays).
Returns Stream<T>
A new stream of sorted elements.
Example
```
const items = [
 { name: "A", age: 18 },
 { name: "B", age: 28 },
 { name: "C", age: 17 }
];
const sorted = Stream.from(items).sortBy(item => item.age).toArray();
```
- Defined in Stream.ts:602

take

take(count: number): Stream<T>
Returns a stream that limits the input to at most count elements.
Parameters
- count: number
Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2, 3];
const result = Stream.from(items).take(1).toArray(); // [1]
```
Count
the number of elements to include in the returned stream
- Defined in Stream.ts:392

takeWhile

takeWhile(predicate: (item: T) => boolean): Stream<T>
Returns a stream over the input that produces values while the predicate returns true. The stream will be cut off when the predicate returns false for the first time.
Parameters
- predicate: (item: T) => boolean
 Determines when including items in the returned stream shall be stopped.
Returns Stream<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const items = [1, 2, 3, 4, -1, -2, -3];
const result = Stream.from(items).takeWhile((n) => n < 4).toArray(); // [1, 2, 3]
```
- Defined in Stream.ts:412

toArray

toArray(): T[]

Gathers all elements of this stream into an array.

Returns T[]

Example

import { Stream } from "apprt-streams/Stream";
const array = Stream.integers(3).toArray(); // [0, 1, 2]

toMap

toMap(
this: T extends [any, any] ? Stream<T> : never,
): T extends [K, V] ? Map<K, V> : never
Gathers the elements of this stream into a map. The elements must be [key, value] pairs.

Note: elements are inserted into the map in the order they occur in the stream. Iterating over the map will yield the same order because maps maintain their insertion order.
Parameters
- this: T extends [any, any] ? Stream<T> : never
Returns T extends [K, V] ? Map<K, V> : never
Example
```
import { Stream } from "apprt-streams/Stream";
const map = Stream.from(["a", "b", "c"])
 .map((v) => [v, v + "!"])
 .toMap(); // // a -> a!, b -> b!, c -> c!
```
- Defined in Stream.ts:985

toObject

toObject(
 this: T extends [PropertyKey, any] ? Stream<T> : never,
): T extends [K, V]
 ? [K] extends [PropertyKey] ? Record<K<K>, V> : never
 : never
Gathers all elements of this stream into an object. The elements must be [key, value] pairs, and the keys must be strings, symbols or numbers.
Parameters
- this: T extends [PropertyKey, any] ? Stream<T> : never
Returns T extends [K, V] ? [K] extends [PropertyKey] ? Record<K<K>, V> : never : never
Example
```
import { Stream } from "apprt-streams/Stream";
const object = Stream.from(["a", "b", "c"])
 .map((v) => [v, v + "!"])
 .toObject(); // { a: "a!", b: "b!", c: "c!"}
```
- Defined in Stream.ts:938

toSet

toSet(): Set<T>
Gathers all elements of this stream into a set.

Note: elements are inserted into the set in the order they occur in the stream. Iterating over the set will yield the same order because sets maintain their insertion order.

Returns Set<T>
Example
```
import { Stream } from "apprt-streams/Stream";
const set = Stream.integers(3).toSet(); // set of 0, 1, 2
```
- Defined in Stream.ts:963

unique

unique(): Stream<T>
Returns a stream that consists of all elements of this stream, with duplicates removed. The relative order of the remaining elements is preserved.

NOTE: This function reads the entire stream into memory and stores all elements in a Set for de-duplication. This may be inefficient for very large datasets.

Returns Stream<T>
A new stream with unique items.
Example
```
const items = [
 {age: 1},
 {age: 2},
 {age: 3},
 {age: 1},
 {age: 3},
 {age: 3}
];
const result = Stream.from(items).map(i => i.age).unique().toArray();
// result == [1, 2, 3]
```
- Defined in Stream.ts:630

zipLongestWith

zipLongestWith<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<[undefined | T, ...ZipLongestValue<Ts>[]]>
Zips the given iterables with this with the zipLongest algorithm (see static zipLongest function for details). The length of the resulting stream is the maximum length of all iterables, with empty positions filled with undefined.
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 a series of iterables who's items will be zipped next to the items of this.
Returns Stream<[undefined | T, ...ZipLongestValue<Ts>[]]>
- Defined in Stream.ts:497

zipWith

zipWith<Ts extends Iterable[] | [Iterable]>(
...iterables: Ts,
): Stream<[T, ...MapIterableValues<Ts>[]]>
Zips the given iterables with this (see static zip function for details). The length of the resulting stream is the minimum length of all iterables.
Type Parameters
- Ts extends Iterable[] | [Iterable]
Parameters
- ...iterables: Ts
 a series of iterables who's items will be zipped next to the items of this.
Returns Stream<[T, ...MapIterableValues<Ts>[]]>
- Defined in Stream.ts:485

Class Stream<T>Abstract

Type Parameters

Implements

Index

Methods

Methods

StaticallIntegers

Parameters

Returns Stream<number>

Example

Staticconcat

Type Parameters

Parameters

Returns Stream<ConcatValue<Ts>>

Example

Staticempty

Type Parameters

Returns Stream<U>

Example

Staticentries

Type Parameters

Parameters

Returns Stream<[key: K, value: U]>

Example

Staticenumerate

Type Parameters

Parameters

Returns Stream<[index: number, value: U]>

Example

Staticfrom

Type Parameters

Parameters

Returns Stream<U>

Example

Type Parameters

Parameters

Returns Stream<U>

Example

Staticgenerate

Type Parameters

Parameters

Returns Stream<U>

Example

Staticintegers

Parameters

Returns Stream<number>

Example

Parameters

Returns Stream<number>

Example

Statickeys

Type Parameters

Parameters

Returns Stream<K>

Example

Staticof

Type Parameters

Parameters

Returns Stream<U>

Staticvalues

Type Parameters

Parameters

Returns Stream<U>

Example

Staticzip

Type Parameters

Parameters

Returns Stream<MapIterableValues<Ts>>

Example

StaticzipLongest

Type Parameters

Parameters

Returns Stream<ZipLongestValue<Ts>>

Example

Abstract[iterator]

Returns Iterator<T>

Example

chunk

Parameters

Returns Stream<T[]>

Class Stream<T>`Abstract`

`Static`allIntegers

`Static`concat

`Static`empty

`Static`entries

`Static`enumerate

`Static`from

`Static`generate

`Static`integers

`Static`keys

`Static`of

`Static`values

`Static`zip

`Static`zipLongest

`Abstract`[iterator]