Class LazyStream<T>

LazyStream: Handles asynchronous data lazily.

This class enables lazy, on-demand processing of async data sources, such as paginated API responses or infinite streams.

Features:

Lazy Evaluation: Data is only processed when requested.
Functional API: Supports chaining with map(), filter(), and take().
Async Generators: Works with async data sources seamlessly.

Type Parameters

T
The type of elements processed by the stream.

Index

Constructors

Methods

filter map take toArray from

Constructors

constructor

new LazyStream<T>(generatorFn): LazyStream<T>
Creates a new LazyStream instance.
Type Parameters
- T
Parameters
- generatorFn: (() => AsyncGenerator<T, void, unknown>)
  An async generator function.
  - - (): AsyncGenerator<T, void, unknown>
    - Returns AsyncGenerator<T, void, unknown>
Returns LazyStream<T>
- Defined in functional/lazy/LazyStream.ts:26

Methods

filter

filter(predicate): LazyStream<T>
Lazily filters elements based on a predicate function.
Parameters
- predicate: ((value: T) => boolean | Promise<boolean>)
  The filtering function.
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns LazyStream<T>
- A new filtered LazyStream.
Example
```
const evens = stream.filter(x => x % 2 === 0);
```
- Defined in functional/lazy/LazyStream.ts:87

map

map<U>(fn): LazyStream<U>
Lazily applies a transformation function to each element.
Type Parameters
- U
  The transformed type.
Parameters
- fn: ((value: T) => U | Promise<U>)
  Transformation function.
  - - (value): U | Promise<U>
    - Parameters
      value: T
      Returns U | Promise<U>
Returns LazyStream<U>
- A new LazyStream instance.
Example
```
const doubled = stream.map(x => x * 2);
```
- Defined in functional/lazy/LazyStream.ts:68

take

take(n): LazyStream<T>
Lazily takes the first n elements.
Parameters
- n: number
  Number of elements to take.
Returns LazyStream<T>
- A new LazyStream instance.
Example
```
const firstFive = stream.take(5);
```
- Defined in functional/lazy/LazyStream.ts:106

toArray

toArray(): Promise<T[]>
Collects the stream into an array.

Note: This forces evaluation of all elements (breaking laziness).

Returns Promise<T[]>
- A promise resolving to an array of values.
Example
```
const values = await stream.toArray();
```
- Defined in functional/lazy/LazyStream.ts:128

`Static`from

from<T>(fn): LazyStream<T>
Creates a LazyStream from an async generator function.
Type Parameters
- T
  The type of elements produced.
Parameters
- fn: (() => AsyncGenerator<T, void, unknown>)
  The generator function.
  - - (): AsyncGenerator<T, void, unknown>
    - Returns AsyncGenerator<T, void, unknown>
Returns LazyStream<T>
- A new LazyStream instance.
Example
```
async function* numbers() {
    let i = 1;
    while (true) yield i++;
}
const stream = LazyStream.from(numbers);
```
- Defined in functional/lazy/LazyStream.ts:44