interface Stream.NonEmpty<T>

A non-empty and possibly infinite sequence of elements of type T. See the Stream documentation and the Stream API documentation

Extends: Streamable.NonEmpty<T>, Stream<T>

Type parameters

Name	Description
T	the element type

Methods

[Symbol.iterator]

Returns a FastIterator instance used to iterate over the values of this Iterable.

Definition

[Symbol.iterator](): FastIterator<T>;

Overrides

FastIterable.[Symbol.iterator]

append

Returns the current stream succeeded by the given value

Definition

append(value: OptLazy<T>): Stream.NonEmpty<T>;

Parameters

Name	Type	Description
value	OptLazy<T>	the value to append

example

Stream.of(1, 2, 3).append(4).toArray()
// => [1, 2, 3, 4]

note

O(1)

Overrides

Stream.append

asNormal

Returns this collection typed as a 'possibly empty' collection.

Definition

asNormal(): Stream<T>;

example

Stream.of(0, 1, 2).asNormal();  // type: Stream<number>

assumeNonEmpty

Returns the stream as a non-empty instance.

Definition

assumeNonEmpty(): Stream.NonEmpty<T>;

throws

RimbuError.EmptyCollectionAssumedNonEmptyError if the stream is known to be empty.

example

Stream.range({ amount: 100 }).assumeNonEmpty()
// => type: Stream.NonEmpty<number>

note

the function does not actually check if the stream is empty, so treat with extra care @note O(1)

Overrides

Stream.assumeNonEmpty

collect

Returns a Stream containing the resulting elements from applying the given collectFun to each element in this Stream.

Definition

collect<R>(collectFun: CollectFun<T, R>): Stream<R>;

Type parameters

Name	Description
R	the result element type

Parameters

Name	Type	Description
collectFun	CollectFun<T, R>	a function taking the parameters below and returning a new element or a skip token - value: the next element - index: the element index - skip: an element that can be returned if the current element should be skipped - halt: a function that, if called, ensures that no new elements are passed

example

Stream.of(1, 2, 3).collect((v, i, skip, halt) => {
if (i === 0) return skip;
if (i === 1) halt();
return String(v)
}).toArray();
// => ['1']

note

O(1)

Overrides

Stream.collect

concat

Returns a Stream containing the elements of this Stream followed by all elements produced by the others array of StreamSources.

Definition

concat<T2 = T>(...others: ArrayNonEmpty<StreamSource<T2>>): Stream.NonEmpty<T | T2>;

Type parameters

Name	Default	Description
T2	T

Parameters

Name	Type	Description
others	ArrayNonEmpty<StreamSource<T2>>	a series of StreamSources to concatenate.

example

Stream.of(1, 2, 3).concat([4, 5], [6, 7]).toArray()
// [1, 2, 3, 4, 5, 6, 7]

note

O(1)

Overrides

Stream.concat

contains

Returns true if the Stream contains given amount instances of given value, using given eq function.

Definition

contains(value: T, options?: {
    amount?: number | undefined;
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
  }): boolean;

Parameters

Name	Type	Description
value	T	the value to search for
options	{     amount?: number | undefined;     eq?: Eq<T> | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties = amount: (default: 1) the amount of values the Stream should contain - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given predicate

example

Stream.from('marmot').contains('m')                // => true
Stream.from('marmot').contains('m', { amount: 2 }) // => true
Stream.from('marmot').contains('m', { amount: 3 }) // => false
Stream.from('marmot').contains('q')                // => false

note

O(N)

Overrides

Stream.contains

containsSlice

Returns true if this stream contains the same sequence of elements as the given source, false otherwise.

Definition

containsSlice(source: StreamSource.NonEmpty<T>, options?: {
    eq?: Eq<T> | undefined;
    amount?: number | undefined;
  }): boolean;

Parameters

Name	Type	Description
source	StreamSource.NonEmpty<T>	a non-empty stream source containing the element sequence to find
options	{     eq?: Eq<T> | undefined;     amount?: number | undefined;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the function to use to test element equality

example

Stream.of(1, 2, 3, 4, 5).containsSlice([2, 3, 4])
// => true
Stream.of(1, 2, 3, 4, 5).containsSlice([4, 3, 2])
// => false

Overrides

Stream.containsSlice

count

Returns the amount of elements in the Stream.

Definition

count(): number;

example

Stream.of(1, 2, 3).count() // => 3

note

O(N) for most types of Stream @note be careful not to use on infinite streams

Overrides

Stream.count

countElement

Returns the amount of elements that are equal according to the given eq to the given value in the Stream.

Definition

countElement(value: T, options?: {
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
  }): number;

Parameters

Name	Type	Description
value	T	the value to compare to
options	{     eq?: Eq<T> | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given Eq function

example

Stream.of(1, 2, 3).countElement(2) // => 1
Stream.of(1, 2, 3).countElement(2, { negate: true }) // => 2

note

O(N) for most types of Stream @note be careful not to use on infinite streams

Overrides

Stream.countElement

distinctPrevious

Returns a non-empty Stream containing non-repetitive elements of the source stream, where repetitive elements are compared using the optionally given eq equality function.

Definition

distinctPrevious(options?: {
      eq?: Eq<T> | undefined;
      negate?: boolean | undefined;
    }): Stream.NonEmpty<T>;

Parameters

Name	Type	Description
options	{       eq?: Eq<T> | undefined;       negate?: boolean | undefined;     }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 1, 2, 2, 3, 1).distinctPrevious().toArray()
// => [1, 2, 3, 1]

Overrides

Stream.distinctPrevious

drop

Returns a stream that skips the first amount elements of this Stream and returns the rest.

Definition

drop(amount: number): Stream<T>;

Parameters

Name	Type	Description
amount	number	the amount of elements to skip

example

Stream.of(1, 2, 3).drop(1).toArray()   // => [2, 3]

note

O(N) for most types of Stream

Overrides

Stream.drop

dropWhile

Returns a Stream that contains the elements of this Stream starting from the first element that does not satisfy given pred function.

Definition

dropWhile(pred: (value: T, index: number) => boolean, options?: {
    negate?: boolean | undefined;
  }): Stream<T>;

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     negate?: boolean | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).dropWhile(v => v < 2).toArray()
// => [2, 3]

note

O(N)

Overrides

Stream.dropWhile

elementAt

Returns the element in the Stream at the given index, or a fallback value (default undefined) otherwise.

Definitions

elementAt(index: number): T | undefined;

elementAt<O>(index: number, otherwise: OptLazy<O>): T | O;

Parameters

Name	Type	Description
index	number	the index of the element to retrieve

example

Stream.of(1, 2, 3).elementAt(1)        // => 2
Stream.of(1, 2, 3).elementAt(5)        // => undefined
Stream.of(1, 2, 3).elementAt(5, 'a')   // => 'a'

note

O(N) for most types of Stream

Overrides

Stream.elementAt

equals

Returns true if the sequence of elements in this stream are equal to the sequence in the other stream according to the provided eq function.

Definition

equals(other: StreamSource<T>, options?: {
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
  }): boolean;

Parameters

Name	Type	Description
other	StreamSource<T>	the other stream to compare
options	{     eq?: Eq<T> | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the eq function

example

Stream.of(1, 2, 3).equals([1, 2, 3])     // => true
Stream.of(1, 2, 3, 4).equals([1, 2, 3])  // => false

note

don't use on potentially infinite streams @note O(N)

Overrides

Stream.equals

every

Returns true if every element of the Stream satifies given pred function.

Definition

every(pred: (value: T, index: number) => boolean, options?: {
    negate?: boolean | undefined;
  }): boolean;

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     negate?: boolean | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).every((v, i) => v + i > 10)  // => false
Stream.of(1, 2, 3).every((v, i) => v + i < 10)  // => true

note

O(N)

Overrides

Stream.every

filter

Returns a Stream containing only those elements from this Stream for which the given pred function returns true.

Definitions

filter<TF extends T>(pred: (value: T, index: number, halt: () => void) => value is TF, options?: {
    negate?: false | undefined;
  }): Stream<TF>;

filter<TF extends T>(pred: (value: T, index: number, halt: () => void) => value is TF, options: {
    negate: true;
  }): Stream<Exclude<T, TF>>;

filter(pred: (value: T, index: number, halt: () => void) => boolean, options?: {
    negate?: boolean | undefined;
  }): Stream<T>;

Type parameters

Name	Constraints	Description
TF	T

Parameters

Name	Type	Description
pred	(value: T, index: number, halt: () => void) => value is TF	a function taking an element and its index, and returning true if the element should be included in the resulting Stream.
options	{     negate?: false | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

note

O(1)

example

Stream.of(1, 2, 3).filter((v, i) => v + i !== 3).toArray()
// => [1, 3]
Stream.of(1, 2, 3).filter((v, i) => v + i !== 3, { negate: true }).toArray()
// => [2]

Overrides

Stream.filter

filterPure

Returns a Stream containing only those elements from this Stream for which the given pred function returns true.

Definitions

filterPure<A extends readonly unknown[], TF extends T>(options: {
    pred: (value: T, ...args: A) => value is TF;
    negate?: false | undefined;
  }): Stream<TF>;

filterPure<A extends readonly unknown[], TF extends T>(options: {
    pred: (value: T, ...args: A) => value is TF;
    negate: true;
  }): Stream<Exclude<T, TF>>;

filterPure<A extends readonly unknown[]>(options: {
    pred: (value: T, ...args: A) => boolean;
    negate?: boolean | undefined;
  }, ...args: A): Stream<T>;

Type parameters

Name	Constraints	Description
A	readonly unknown[]	the arguments to be supplied to the pred function after each element
TF	T

Parameters

Name	Type	Description
options	{     pred: (value: T, ...args: A) => value is TF;     negate?: false | undefined;   }	object specifying the following properties - pred: a function taking an element the optionaly given args, and returning true if the element should be included in the resulting Stream. - negate: (default: false) when true will negate the given predicate

note

O(1)

example

Stream.of(1, 2, 3).filterPure({ pred: Object.is }, 2).toArray()
// => [2]
Stream.of(1, 2, 3).filterPure({ pred: Object.is, negate: true }, 2).toArray()
// => [1, 3]

Overrides

Stream.filterPure

find

Returns the first element for which the given pred function returns true, or a fallback value otherwise.

Definitions

find<O, TF extends T>(pred: (value: T, index: number) => value is TF, options: {
    occurrance?: number | undefined;
    negate?: false | undefined;
    otherwise: OptLazy<O>;
  }): TF | O;

find<O, TF extends T>(pred: (value: T, index: number) => value is TF, options: {
    occurrance?: number | undefined;
    negate: true;
    otherwise: OptLazy<O>;
  }): Exclude<T, TF> | O;

find<TF extends T>(pred: (value: T, index: number) => value is TF, options?: {
    occurrance?: number | undefined;
    negate?: false | undefined;
    otherwise?: undefined;
  }): TF | undefined;

find<TF extends T>(pred: (value: T, index: number) => value is TF, options?: {
    occurrance?: number | undefined;
    negate: true;
    otherwise?: undefined;
  }): Exclude<T, TF> | undefined;

find<O>(pred: (value: T, index: number) => boolean, options: {
    occurrance?: number | undefined;
    negate?: boolean | undefined;
    otherwise: OptLazy<O>;
  }): T | O;

find(pred: (value: T, index: number) => boolean, options?: {
    occurrance?: number | undefined;
    negate?: boolean | undefined;
    otherwise?: undefined;
  }): T | undefined;

Type parameters

Name	Constraints	Description
O		the optional value type to return if no match is found
TF	T

Parameters

Name	Type	Description
pred	(value: T, index: number) => value is TF	a predicate function taking an element and its index
options	{     occurrance?: number | undefined;     negate?: false | undefined;     otherwise: OptLazy<O>;   }	(optional) object specifying the following properties - occurrance: (default: 1) the occurrance number to look for - otherwise: (default: undefined) an OptLazy value to be returned if the Stream is empty

example

const isEven = (v: number) => v % 2 === 0
Stream.of(1, 2, 3, 4).find(isEven)           // => 2
Stream.of(1, 2, 3, 4).find(isEven, { occurrance: 2 })        // => 4
Stream.of(1, 2, 3, 4).find(isEven, { occurrance: 3 })        // => undefined
Stream.of(1, 2, 3, 4).find(isEven, { occurrance: 3, otherwise: 'a' })
// => 'a'

note

O(N) for most types of Stream

Overrides

Stream.find

first

Returns the first element of the Stream.

Definition

first(): T;

example

Stream.of(1, 2, 3).first()      // => 1

note

O(1)

Overrides

Stream.first

flatMap

Returns a Stream consisting of the concatenation of flatMapFun applied to each element.

Definitions

flatMap<T2>(flatMapFun: (value: T, index: number) => StreamSource.NonEmpty<T2>): Stream.NonEmpty<T2>;

flatMap<T2>(flatMapFun: (value: T, index: number, halt: () => void) => StreamSource<T2>): Stream<T2>;

Type parameters

Name	Description
T2	the result element type

Parameters

Name	Type	Description
flatMapFun	(value: T, index: number) => StreamSource.NonEmpty<T2>	a function receiving the inputs described below and returning a StreamSource of new elements - value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed

note

O(1)

example

Stream.of(1, 2, 3).flatMap((v, i, halt) => {
if (i >= 1) halt();
return [v, i, v + i]
}).toArray()
// => [1, 0, 1, 2, 1, 3]

Overrides

Stream.flatMap

flatZip

Returns a Stream consisting of the concatenation of flatMapFun applied to each element, zipped with the element that was provided to the function.

Definitions

flatZip<T2>(flatMapFun: (value: T, index: number) => StreamSource.NonEmpty<T2>): Stream.NonEmpty<[T, T2]>;

flatZip<T2>(flatMapFun: (value: T, index: number, halt: () => void) => StreamSource<T2>): Stream<[T, T2]>;

Type parameters

Name	Description
T2	the result element type

Parameters

Name	Type	Description
flatMapFun	(value: T, index: number) => StreamSource.NonEmpty<T2>	a function receiving the inputs described below and returning a StreamSource of new elements - value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed

note

O(1)

example

Stream.of(1, 2, 3).flatZip((v, i, halt) => {
if (i >= 1) halt();
return [v, i, v + i]
}).toArray()
// => [[1, 1], [1, 0], [1, 1], [2, 2], [2, 1], [2, 3]]

Overrides

Stream.flatZip

fold

Returns the value resulting from applying the given the given next function to a current state (initially the given init value), and the next Stream value, and returning the new state. When all elements are processed, the resulting state is returned.

Definition

fold<R>(init: OptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => R): R;

Type parameters

Name	Description
R	the resulting element type

Parameters

Name	Type	Description
init	OptLazy<R>	the initial result/state value
next	(current: R, value: T, index: number, halt: () => void) => R	a function taking the parameters below and returning the new result/state value - current: the current result/state value, initially init. - value: the next Stream value - index: the index of the given value - halt: a function that, if called, ensures that no new elements are passed

example

console.log(Stream.empty<number>().fold(5, (current, value) => current + value))
// => 5
console.log(Stream.of(1, 2, 3).fold(5, (current, value) => current + value))
// => 11  (= 5 + 1 + 2 + 3)

Overrides

Stream.fold

foldStream

Returns a Stream containing the values resulting from applying the given the given next function to a current state (initially the given init value), and the next Stream value, and returning the new state.

Definitions

foldStream<R>(init: OptLazy<R>, next: (current: R, value: T, index: number) => R): Stream.NonEmpty<R>;

foldStream<R>(init: OptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => R): Stream<R>;

Type parameters

Name	Description
R	the resulting element type

Parameters

Name	Type	Description
init	OptLazy<R>	the initial result/state value
next	(current: R, value: T, index: number) => R	a function taking the parameters below and returning the new result/state value - current: the current result/state value, initially init. - value: the next Stream value - index: the index of the given value - halt: a function that, if called, ensures that no new elements are passed

example

console.log(
Stream.empty<number>()
.foldStream(5, (current, value) => current + value)
.toArray()
)
// => []
console.log(
Stream.of(1, 2, 3)
.foldStream(5, (current, value) => current + value)
.toArray()
)
// => [6, 8, 11]

Overrides

Stream.foldStream

forEach

Performs given function f for each element of the Stream, using given state as initial traversal state.

Definition

forEach(f: (value: T, index: number, halt: () => void) => void, options?: {
    state?: TraverseState | undefined;
  }): void;

Parameters

Name	Type	Description
f	(value: T, index: number, halt: () => void) => void	the function to perform for each element, receiving: - value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed
options	{     state?: TraverseState | undefined;   }	(optional) object specifying the following properties - state: (optional) the traverse state

example

Stream.of(1, 2, 3).forEach((v, i, halt) => {
console.log(v);
if (i >= 1) halt();
})
// => 1, 2

note

O(N)

Overrides

Stream.forEach

forEachPure

Performs given function f for each element of the Stream, with the optionally given args as extra arguments.

Definition

forEachPure<A extends readonly unknown[]>(f: (value: T, ...args: A) => void, ...args: A): void;

Type parameters

Name	Constraints	Description
A	readonly unknown[]	the type of the extra arguments to pass

Parameters

Name	Type	Description
f	(value: T, ...args: A) => void	the function to perform for each element, optionally receiving given extra args.
args	A	a list of extra arguments to pass to given f for each element when needed

example

Stream.of(1, 2, 3).forEachPure(console.log, 'sheep')
// => logs:
// 1 sheep
// 2 sheep
// 3 sheep

note

O(N)

Overrides

Stream.forEachPure

groupBy

Returns the result of applying the valueToKey function to calculate a key for each value, and feeding the tuple of the key and the value to the collector reducer, and finally returning its result. If no collector is given, the default collector will return a JS multimap of the type Map<K, V[]>.

Definitions

groupBy<K, R, T2 extends readonly [K, T] = [K, T]>(valueToKey: (value: T, index: number) => K, options: {
    collector: Reducer<[K, T] | T2, R>;
  }): R;

groupBy<K>(valueToKey: (value: T, index: number) => K, options?: {
    collector?: undefined;
  }): Map<K, T[]>;

Type parameters

Name	Constraints	Default	Description
K			the key type
R			the collector output type
T2	readonly [K, T]	[K, T]

Parameters

Name	Type	Description
valueToKey	(value: T, index: number) => K	function taking a value and its index, and returning the corresponding key
options	{     collector: Reducer<[K, T] | T2, R>;   }	(optional) an object containing the following properties: - collector: (default: Reducer.toArray()) a reducer that collects the incoming tuple of key and value, and provides the output

example

Stream.of(1, 2, 3).groupBy((v) => v % 2)
// => Map {0 => [2], 1 => [1, 3]}

Overrides

Stream.groupBy

indexed

Returns a non-empty Stream where each element in this Stream is paired with its index

Definition

indexed(options?: {
      startIndex?: number | undefined;
    }): Stream.NonEmpty<[number, T]>;

Parameters

Name	Type	Description
options	{       startIndex?: number | undefined;     }	(optional) object specifying the following properties - startIndex: (optional) an alternative start index to use

example

Stream.of(1, 2, 3).indexed().toArray()
// => [[0, 1], [1, 2], [2, 3]]

note

O(1)

Overrides

Stream.indexed

indexOf

Returns the index of the occurrance instance of given searchValue in the Stream, using given eq function, or undefined if no such value is found.

Definition

indexOf(searchValue: T, options?: {
    occurrance?: number | undefined;
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
  }): number | undefined;

Parameters

Name	Type	Description
searchValue	T	the element to search for
options	{     occurrance?: number | undefined;     eq?: Eq<T> | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties - occurrance: (default: 1) the occurrance to search for - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given Eq function

example

const source = Stream.from('marmot')
source.indexOf('m')     // => 0
source.indexOf('m', 2)  // => 3
source.indexOf('m', 3)  // => undefined
source.indexOf('q')     // => undefined

note

O(N)

Overrides

Stream.indexOf

indexWhere

Returns the index of the given occurrance instance of the element in the Stream that satisfies given pred function, or undefined if no such instance is found.

Definition

indexWhere(pred: (value: T, index: number) => boolean, options?: {
    occurrance?: number | undefined;
    negate?: boolean | undefined;
  }): number | undefined;

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     occurrance?: number | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties - occurrance: (default: 1) the occurrance to search for - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).indexWhere((v, i) => v + i > 2)      // => 1
Stream.of(1, 2, 3).indexWhere((v, i) => v + i > 2, 2)   // => 2

note

O(N)

Overrides

Stream.indexWhere

indicesOf

Returns a Stream containing the indicies of the occurrance of the given searchValue, according to given eq function.

Definition

indicesOf(searchValue: T, options?: {
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
  }): Stream<number>;

Parameters

Name	Type	Description
searchValue	T	the value to search for
options	{     eq?: Eq<T> | undefined;     negate?: boolean | undefined;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given Eq function

example

Stream.from('marmot').indicesOf('m').toArray()
// => [0, 3]

note

O(N)

Overrides

Stream.indicesOf

indicesWhere

Returns a Stream containing the indices of the elements for which the given pred function returns true.

Definition

indicesWhere(pred: (value: T) => boolean, options?: {
    negate?: boolean | undefined;
  }): Stream<number>;

Parameters

Name	Type	Description
pred	(value: T) => boolean	a predicate function taking an element
options	{     negate?: boolean | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).indicesWhere((v, i) => v + i !== 3).toArray()
// => [0, 2]

note

O(N)

Overrides

Stream.indicesWhere

intersperse

Returns a non-empty Stream with all elements from the given sep StreamSource between two elements of this Stream.

Definition

intersperse(sep: StreamSource<T>): Stream.NonEmpty<T>;

Parameters

Name	Type	Description
sep	StreamSource<T>	the StreamSource to insert between each element of this Stream

example

Stream.of(1, 2, 3).intersperse("ab").toArray()
// => [1, 'a', 'b', 2, 'a', 'b', 3]

note

O(1)

Overrides

Stream.intersperse

join

Returns a string resulting from converting each element to string with options.valueToString, interspersed with options.sep, starting with options.start and ending with options.end.

Definition

join(options?: {
    sep?: string | undefined;
    start?: string | undefined;
    end?: string | undefined;
    valueToString?: ((value: T) => string) | undefined;
    ifEmpty?: string | undefined;
  }): string;

Parameters

Name	Type	Description
options	{     sep?: string | undefined;     start?: string | undefined;     end?: string | undefined;     valueToString?: ((value: T) => string) | undefined;     ifEmpty?: string | undefined;   }	(optional) object specifying the following properties - sep: (optional) a seperator to insert between each Stream element - start: (optional) a start string to prepend at the start - end: (optional) an end string to append at the end - valueToString: (default: String) a function converting a Stream element to a string - ifEmpty: (optional) a string to return instead of the start and end tag if the stream is empty

example

Stream.of(1, 2, 3).join({ start: '<', sep: ', ', end: '>' })
// => '<1, 2, 3>'

note

O(N)

Overrides

Stream.join

last

Returns the last element of the Stream.

Definition

last(): T;

example

Stream.of(1, 2, 3).last()      // => 3

note

O(N) for most types of Stream

Overrides

Stream.last

map

Returns a non-empty Stream where mapFun is applied to each element.

Definition

map<T2>(mapFun: (value: T, index: number) => T2): Stream.NonEmpty<T2>;

Type parameters

Name	Description
T2	the result value type

Parameters

Name	Type	Description
mapFun	(value: T, index: number) => T2	a function taking an element and its index, and returning some new element

example

Stream.of(1, 2, 3).map((v, i) => `[${i}]: ${v}`).toArray()
// => ['[0]: 1', '[1]: 2', '[2]: 3']

note

O(1)

Overrides

Stream.map

mapPure

Returns a non-empty tream where the given mapFun is applied to each value in the stream, with optionally as extra arguments the given args.

Definition

mapPure<T2, A extends readonly unknown[]>(mapFun: (value: T, ...args: A) => T2, ...args: A): Stream.NonEmpty<T2>;

Type parameters

Name	Constraints	Description
T2		the result element type
A	readonly unknown[]	the type of the arguments to be passed to the mapFun function after each element

Parameters

Name	Type	Description
mapFun	(value: T, ...args: A) => T2	a function taking an element and the given args, and returning the resulting stream value
args	A	(optional) the extra arguments to pass to the given mapFun

note

is mostly aimed to increase performance so that an extra function is not required @note can be used on function that really expect 1 argument, since the normal map will also pass more arguments

example

const s = Stream.of({ a: 1 }, { a: 2, c: { d: true } })
const s2 = s.mapPure(JSON.stringify, ['a'], 5)
// when stream is evaluated, will call JSON.stringify on each stream element with the given extra arguments
console.log(s2.toArray())
// => ["{\n \"a\": 1\n}", "{\n \"a\": 2\n}"]

Overrides

Stream.mapPure

max

Returns the maximum element of the Stream according to a default compare function.

Definition

max(): T;

example

Stream.of(5, 1, 3).max()         // => 5

note

O(N)

Overrides

Stream.max

maxBy

Returns the maximum element of the Stream according to the provided compare function.

Definition

maxBy(compare: (v1: T, v2: T) => number): T;

Parameters

Name	Type	Description
compare	(v1: T, v2: T) => number

example

function compareLength(a: string, b: string): number { return b.length - a.length };
Stream.of('abc', 'a', 'ab').maxBy(compareLength)   // => 'abc'

note

O(N)

Overrides

Stream.maxBy

min

Returns the mimimum element of the Stream according to a default compare function.

Definition

min(): T;

example

Stream.of(5, 1, 3).min()         // => 1

note

O(N)

Overrides

Stream.min

minBy

Returns the mimimum element of the Stream according to the provided compare function.

Definition

minBy(compare: (v1: T, v2: T) => number): T;

Parameters

Name	Type	Description
compare	(v1: T, v2: T) => number

example

function compareLength(a: string, b: string): number { return b.length - a.length };
Stream.of('abc', 'a', 'ab').minBy(compareLength)   // => 'a'

note

O(N)

Overrides

Stream.minBy

mkGroup

Returns a non-empty Stream starting with options.sep, then returning the elements of this Stream interspersed with options.sep, and ending with options.end.

Definition

mkGroup(options: {
      sep?: StreamSource<T> | undefined;
      start?: StreamSource<T> | undefined;
      end?: StreamSource<T> | undefined;
    }): Stream.NonEmpty<T>;

Parameters

Name	Type	Description
options	{       sep?: StreamSource<T> | undefined;       start?: StreamSource<T> | undefined;       end?: StreamSource<T> | undefined;     }	object specifying the following properties - sep: (optional) a seperator StreamSource to insert between each Stream element - start: (optional) a start StreamSource to prepend - end: (optional) an end StreamSource to append

example

Stream.of(1, 2, 3).mkGroup({ start: '<<', sep: '-', end: '>>' }).toArray()
// => ['<', '<', 1, '-', 2, '-', 3, '>', '>']

note

O(N)

Overrides

Stream.mkGroup

partition

Returns a tuple of which the first element is the result of collecting the elements for which the given predicate is true, and the second one the result of collecting the other elements. Own reducers can be provided as collectors, by default the values are collected into an array.

Definitions

partition<T2 extends T, RT, RF>(pred: (value: T, index: number) => value is T2, options: {
    collectorTrue: Reducer<T2, RT>;
    collectorFalse: Reducer<Exclude<T, T2>, RF>;
  }): [true: RT, false: RF];

partition<T2 extends T>(pred: (value: T, index: number) => value is T2, options?: {
    collectorTrue?: undefined;
    collectorFalse?: undefined;
  }): [true: T2[], false: Exclude<T, T2>[]];

partition<RT, RF, T2 extends T = T>(pred: (value: T, index: number) => boolean, options: {
    collectorTrue: Reducer<T | T2, RT>;
    collectorFalse: Reducer<T | T2, RF>;
  }): [true: RT, false: RF];

partition(pred: (value: T, index: number) => boolean, options?: {
    collectorTrue?: undefined;
    collectorFalse?: undefined;
  }): [true: T[], false: T[]];

Type parameters

Name	Constraints	Description
T2	T
RT		the reducer result type for the collectorTrue value
RF		the reducer result type for the collectorFalse value

Parameters

Name	Type	Description
pred	(value: T, index: number) => value is T2	a predicate receiving the value and its index
options	{     collectorTrue: Reducer<T2, RT>;     collectorFalse: Reducer<Exclude<T, T2>, RF>;   }	(optional) an object containing the following properties: - collectorTrue: (default: Reducer.toArray()) a reducer that collects the values for which the predicate is true - collectorFalse: (default: Reducer.toArray()) a reducer that collects the values for which the predicate is false

note

if the predicate is a type guard, the return type is automatically inferred

Overrides

Stream.partition

prepend

Returns the current stream preceded by the given value

Definition

prepend(value: OptLazy<T>): Stream.NonEmpty<T>;

Parameters

Name	Type	Description
value	OptLazy<T>	the value to prepend

example

Stream.of(1, 2, 3).prepend(0).toArray()
// => [0, 1, 2, 3]

note

O(1)

Overrides

Stream.prepend

reduce

Applies the given reducer to each element in the Stream, and returns the final result.

Definitions

reduce<R, T2 = T>(reducer: Reducer<T | T2, R>): R;

reduce<const S extends Reducer.CombineShape<T>>(shape: S & Reducer.CombineShape<T>): Reducer.CombineResult<S>;

Type parameters

Name	Default	Description
R		the result type
T2	T

Parameters

Name	Type	Description
reducer	Reducer<T | T2, R>	the Reducer instance to use to apply to all Stream elements.

example

console.log(Stream.of(1, 2, 4).reduce(Reducer.sum))
// => 7
console.log(Stream.of(1, 2, 4).reduce(Reducer.product))
// => 8

Overrides

Stream.reduce

reduceStream

Returns a Stream where the given reducer is applied to each element in the Stream.

Definitions

reduceStream<R, T2 = T>(reducer: Reducer<T |T2, R>):Stream<R>;

reduceStream<const S extends Reducer.CombineShape<T>>(shape: S & Reducer.CombineShape<T>): Stream<Reducer.CombineResult<S>>;

Type parameters

Name	Default	Description
R		the resulting element type
T2	T

Parameters

Name	Type	Description
reducer	Reducer<T | T2, R>	the Reducer instance to use to apply to all Stream elements.

example

console.log(
Stream.of(1, 2, 4)
.reduceStream(Reducer.sum)
.toArray()
)
// => [1, 3, 7]
console.log(
Stream.of(1, 2, 4)
.reduceStream(Reducer.product)
.toArray()
)
// => [1, 2, 8]

Overrides

Stream.reduceStream

repeat

Returns a non-empty Stream that returns the elements from this Stream given amount of times.

Definition

repeat(amount?: number |undefined):Stream.NonEmpty<T>;

Parameters

Name	Type	Description
amount	number | undefined	(default: undefined) the amount of times to return this Stream

example

Stream.of(1, 2, 3).repeat()              // => Stream(1, 2, 3, 1, 2, 3, 1, 2, ...)
Stream.of(1, 2, 3).repeat(1).toArray()   // => [1, 2, 3]
Stream.of(1, 2, 3).repeat(3).toArray()   // => [1, 2, 3, 1, 2, 3, 1, 2, 3]
Stream.of(1, 2, 3).repeat(-3).toArray()  // => [1, 2, 3]

note

amount = undefined means that the Stream is repeated indefintely @note amount = 1 means that the Stream is not repeated @note amount < 1 will be normalized to amount = 1 @note O(1)

Overrides

Stream.repeat

single

Returns the first element of the Stream if it only has one element, or a fallback value if the Stream does not have exactly one value.

Definitions

single(): T | undefined;

single<O>(otherwise: OptLazy<O>): T | O;

example

Stream.empty<number>().single()  // => undefined
Stream.of(1, 2, 3).single()      // => undefined
Stream.of(1).single()            // => 1
Stream.of(1, 2, 3).single(0)     // => 0

Overrides

Stream.single

some

Returns true if any element of the Stream satifies given pred function.

Definition

some(pred: (value: T, index: number) => boolean, options?: {
    negate?: boolean | undefined;
  }): boolean;

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     negate?: boolean | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).some((v, i) => v + i > 10) // => false
Stream.of(1, 2, 3).some((v, i) => v + i > 1)  // => true

note

O(N)

Overrides

Stream.some

splitOn

Returns a Stream of collections of Stream elements, where each collection is filled with elements of this Stream up to the next element that equals given sepElem according to the given eq function.

Definitions

splitOn<R, T2 extends T = T>(sepElem: T, options: {
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
    collector: Reducer<T | T2, R>;
  }): Stream<R>;

splitOn(sepElem: T, options?: {
    eq?: Eq<T> | undefined;
    negate?: boolean | undefined;
    collector?: undefined;
  }): Stream<T[]>;

Type parameters

Name	Constraints	Default	Description
R			the result type of the collector and the resulting stream element type
T2	T	T

Parameters

Name	Type	Description
sepElem	T	the separator element to look for
options	{     eq?: Eq<T> | undefined;     negate?: boolean | undefined;     collector: Reducer<T | T2, R>;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given Eq function - collector: (default: Reducer.toArray()) the reducer to use to collect the window values

example

Stream.from('marmot').splitOn('m').toArray()  // => [[], ['a', 'r'], ['o', 't']]

note

O(1)

Overrides

Stream.splitOn

splitOnSlice

Returns a Stream of collections of Stream elements, where each collection is filled with elements of this Stream up to the next sequence of elements that equal the given sepSeq sequence of elements according to the given eq function.

Definitions

splitOnSlice<R, T2 extends T = T>(sepSlice: StreamSource<T>, options: {
    eq?: Eq<T> | undefined;
    collector: Reducer<T | T2, R>;
  }): Stream<R>;

splitOnSlice(sepSlice: StreamSource<T>, options?: {
    eq?: Eq<T> | undefined;
    collector?: undefined;
  }): Stream<T[]>;

Type parameters

Name	Constraints	Default	Description
R			the result type of the collector and the resulting stream element type
T2	T	T

Parameters

Name	Type	Description
sepSlice	StreamSource<T>	a sequence of elements that serves as a separator
options	{     eq?: Eq<T> | undefined;     collector: Reducer<T | T2, R>;   }	(optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - collector: (default: Reducer.toArray()) the reducer to use to collect the window values

example

Stream.from('marmot').splitOnSlice('mo').toArray()  // => [['m', 'a', 'r'], ['t']]

note

O(1)

Overrides

Stream.splitOnSlice

splitWhere

Returns a Stream of collections of Stream elements, where each collection is filled with elements of this Stream up to the next element that satisfies give function pred.

Definitions

splitWhere<R, T2 extends T = T>(pred: (value: T, index: number) => boolean, options: {
    negate?: boolean | undefined;
    collector: Reducer<T | T2, R>;
  }): Stream<R>;

splitWhere(pred: (value: T, index: number) => boolean, options?: {
    negate?: boolean | undefined;
    collector?: undefined;
  }): Stream<T[]>;

Type parameters

Name	Constraints	Default	Description
R			the result type of the collector and the resulting stream element type
T2	T	T

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     negate?: boolean | undefined;     collector: Reducer<T | T2, R>;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate - collector: (default: Reducer.toArray()) the reducer to use to collect the window values

example

Stream.of(1, 2, 3, 4).splitWhere(v => v == 3).toArray()  // => [[1, 2], [4]]

note

O(1)

Overrides

Stream.splitWhere

stream

Returns a non-empty stream of elements of type T.

Definition

stream(): this;

example

Stream.of(1, 2, 3).stream()
// => returns itself

Overrides

NonEmpty.stream, Stream.stream

take

Returns a stream that contains the elements of this Stream up to a maximum of amount elements.

Definition

take(amount: number): Stream<T>;

Parameters

Name	Type	Description
amount	number	the maximum amount of elements to return from the resulting Stream

example

Stream.of(1, 2, 3).take(2).toArray()   // => [1, 2]

note

O(N) for most types of Stream

Overrides

Stream.take

takeWhile

Returns a Stream that contains the elements of this Stream up to the first element that does not satisfy given pred function.

Definition

takeWhile(pred: (value: T, index: number) => boolean, options?: {
    negate?: boolean | undefined;
  }): Stream<T>;

Parameters

Name	Type	Description
pred	(value: T, index: number) => boolean	a predicate function taking an element and its index
options	{     negate?: boolean | undefined;   }	(optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate

example

Stream.of(1, 2, 3).takeWhile(v => v < 3).toArray()
// => [1, 2]

note

O(N)

Overrides

Stream.takeWhile

toArray

Returns a non-empty Array containing all elements in the Stream.

Definition

toArray(): ArrayNonEmpty<T>;

example

Stream.of(1, 2, 3).toArray()   // => [1, 2, 3]

Overrides

Stream.toArray

toJSON

Returns a JSON representation of the Stream.

Definition

toJSON(): ToJSON<T[], 'Stream'>;

note

take care not to call on infinite Streams

example

Stream.of(1, 2, 3).toJSON()   // => { dataType: 'Stream', value: [1, 2, 3] }

Overrides

Stream.toJSON

toString

Returns a string representation of the Stream.

Definition

toString(): string;

note

to avoid issues with potentially infinite stream, this method does not list the Stream elements. To do this, use join.

example

Stream.of(1, 2, 3).toString()   // => 'Stream(...<potentially empty>)'

Overrides

Stream.toString

transform

Returns a Stream consisting of the concatenation of StreamSource elements resulting from applying the given reducer to each element.

Definitions

transform<R, T2 extends T = T>(transformer: Transformer.NonEmpty<T |T2, R>):Stream.NonEmpty<R>;

transform<R, T2 extends T = T>(transformer: Transformer<T |T2, R>):Stream<R>;

Type parameters

Name	Constraints	Default	Description
R			the resulting element type
T2	T	T

Parameters

Name	Type	Description
transformer	Transformer.NonEmpty<T | T2, R>	a reducer taking elements ot type T as input, and returing a StreamSource of element type R

note

O(1)

example

Stream.of(1, 2, 3, 4, 5, 6)
.transform(Transformer.window(3))
.toArray()
// => [[1, 2, 3], [4, 5, 6]]

Overrides

Stream.transform

window

Returns a Stream containing windows of windowSize consecutive elements of the source stream, with each window starting skipAmount elements after the previous one.

Definitions

window<R, T2 extends T = T>(windowSize: number, options: {
    skipAmount?: number | undefined;
    collector: Reducer<T | T2, R>;
  }): Stream<R>;

window(windowSize: number, options?: {
    skipAmount?: number | undefined;
    collector?: undefined;
  }): Stream<T[]>;

Type parameters

Name	Constraints	Default	Description
R			the collector reducer result type
T2	T	T

Parameters

Name	Type	Description
windowSize	number	the size in elements of the windows
options	{     skipAmount?: number | undefined;     collector: Reducer<T | T2, R>;   }	(optional) object specifying the following properties - skipAmount: (default: windowSize) the amount of elements to skip to start the next window - collector: (default: Reducer.toArray()) the reducer to use to collect the window values

example

console.log(Stream.of(1, 2, 3, 4, 5, 6, 7).window(3).toArray())
// => [[1, 2, 3], [4, 5, 6]]
console.log(Stream.of(1, 2, 3, 4, 5).window(3, 1).toArray())
// => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
console.log(Stream.of(1, 2, 3, 4).window(2, 2, Reducer.toJSSet()).toArray())
// => [Set(1, 2), Set(3, 4)]

Overrides

Stream.window

withOnly

Returns a Stream containing only those elements that are in the given values array.

Definition

withOnly<F extends T>(values: F[]): Stream<F>;

Type parameters

Name	Constraints	Description
F	T	a subtype of T to indicate the resulting element type

Parameters

Name	Type	Description
values	F[]	an array of values to include

Overrides

Stream.withOnly

without

Returns a Stream containing all elements except the elements in the given values array.

Definition

without<F extends T>(values: F[]): Stream<T extends Exclude<T, F> ? T : Exclude<T, F>>;

Type parameters

Name	Constraints	Description
F	T	a subtype of T to indicate the resulting element type

Parameters

Name	Type	Description
values	F[]	an array of values to exclude

Overrides

Stream.without