A lightweight, powerful library that provides wrapper classes and utility functions for lazily-evaluating data structures, including support for async sources, and built completely with native JavaScript features.
This package was motivated by my desire to learn how generators work in JavaScript, and then spiralled into learning how to setup and publich a fully featured NPM package. It was partly inspired by the pythonic package.
It is written in TypeScript, tested with Jest, linted with ESLint, formatted with Prettier, bundled with Rollup, and documented with TSDoc.
Using npm:
npm install @jderrington/lazy-iterable
Using yarn:
yarn add @jderrington/lazy-iterable
Importing
const {LazyIterable} = require("@jderrington/lazy-iterable");
// Or
import {LazyIterable} from "@jderrington/lazy-iterable";
Using script tags:
/* Take the index.js file from the dist/ folder */
<script src="index.js"></script>
<script>
/* Imports are under the 'LazyIterableLib' name */
const {LazyIterable} = LazyIterableLib;
</script>
See the documentation for full the full API specification and examples. There are also examples of usage with Node streams and pagination.
Provides Python and Haskell style functions such as enumerate
, range
, zip
and repeat
, as well as lazy methods such as take
, and drop
(and many more).
// Track the index in a for loop instead of requiring `forEach`
for (const [index, value] of enumerate([1, 2, 3, 4, 5])) {
// Loop body
}
// Python style range iteration
for(const i of range(0, 5)) {
// Loop body
}
// Haskell style lazy evaluation
repeat(5).take(5).toArray() // Returns [5, 5, 5, 5, 5]
// Use familiar array methods on infinite data sources
infinite()
.map((value, index) => `${index}: ${value}`)
.take(3)
.join(", "); // Returns "0: 1, 1: 2, 2: 3"
The iterable to enumerate
Async version of enumerate.
The async iterable to enumerate
Returns a LazyIterable that yields an unending steam of numbers, starting at start
and separated by step
.
Both start
and step
default to 1.
The first number yielded from the LazyIterable
The gap between sucessive yielded values
Returns a LazyIterable that yields values between start
(inclusive) and stop
(exclusive), in steps of size step
(default 1).
Start
can be greater than stop
, in which case the LazyIterable will yield decreasing values - step
should still be positive in this case.
The first value to be yielded from the LazyIterable
The bound on the last value to be yielded
The difference between successive yielded values
Returns a LazyIterable that yields the given value infinitely.
Returns a LazyIterable that yields pairs of values as an array, generated by iterating both provided iterables. The number of elements yielded by the resulting LazyIterable is the length of the shorter of the two iterables.
Returns a LazyIterable that yields values generated by zipping the two given iterables and passing the results through the provided callback; effectively, a combination of zip and map.
Generated using TypeDoc
Returns a LazyIterable that yields the elements of the given iterable alongside the index as an array pair.
This method is lazy, as opposed to the built in
Array.forEach()
method. This means it can be chained with other methods without building intermediate arrays, or as a more powerful version of afor..of
loop.Enumerate an iterable
enumerateAsync for the async version