An iterable object that lazily implements many Array.prototype members.
Extended iterable class, providing lazy array-like methods with automatic async and return/throw forwarding
Get the first fulfilled promise that satisfies the provided testing function
A Tiny Fully-Typed tree shakable lazy iterable library for JavaScript / TypeScript. Combine and iterate over any iterable object or array with a simple chainable API.
A tiny, zero-dependency yet spec-compliant asynchronous iterator polyfill/ponyfill for ReadableStreams.
[](http://www.typescriptlang.org/) [](https://www.npmjs.com/package/@n1ru4l/push-pull-async
Define a lazily evaluated property on an object
Lazy assertions without performance penalty
Convert a string/promise/array/iterable/asynciterable/buffer/typedarray/arraybuffer/object into a stream
Iterable wrapper that add methods to read ahead or behind current item.
Cache requires to be lazy-loaded when needed.
Deques are a generalization of stacks and queues
Lazy value.
Iterable SDK for React Native.
Import a module lazily
The Interactive Extensions for JavaScript
Lazy lists for node
Array manipulation, ordering, searching, summarizing, etc.
React Component to lazy load images using a HOC to track window scroll position.
Split an iterable into evenly sized chunks
Build chainable fluent interfaces the easy way... with a freakin' chainsaw!
Open Node Streams on demand.
A tiny but capable push & pull stream library for TypeScript and Flow
Convert streaming iterables to Node.js streams
a well-understood interface to build lazy enumerator for iterating time points
The laziest possible enumerables and enumerators
== Synopsys Ruby Enumerable extension. Main idea is lazy computations within enumerators. == Usage Install as a gem: sudo gem install deferred_enum This gem introduces DeferredEnumerator class: ary = [1, 2, 3, 4] deferred = ary.defer # #<DeferredEnumerator: [1, 2, 3, 4]:each> DeferredEnumerator brings some optimizations to all?, any? and none? predicates deferred.all?(&:even?) # Will stop iteration after first false-result = 1 iteration deferred.none?(&:even?) # 2 iterations deferred.any?(&:even?) # 2 iterations It also introduces lazy versions of Enumerable's #select, #map and #reject methods deferred.map { |i| i + 1 } # #<DeferredEnumerator: #<Enumerator::Generator>:each> deferred.select { |i| i.even? } # #<DeferredEnumerator: #<Enumerator::Generator>:each> deferred.reject { |i| i.odd? } # #<DeferredEnumerator: #<Enumerator::Generator>:each> So you can safely chain your filters, they won't be treated as arrays: deferred.map(&:succ).select(&:even?) # #<DeferredEnumerator: #<Enumerator::Generator>:each> You can build chains of Enumerables: deferred.concat([2]).to_a # [1, 2, 3, 4, 2] Or append elements to the end of enumerator: deferred << 2 You can even remove duplicates from enumerator, though this operation can be tough: deferred.uniq # #<DeferredEnumerator: #<Enumerator::Generator>:each> There are many other methods in DeferredEnumerator, please refer to documentation.
Flexible and human-friendly Cartesian product enumerator for Ruby. Supports functions and conditions on cartesian, dimensionality-agnostic/dimensionality-aware iterators, named dimensions, tabular output, lazy/eager evaluation, progress bar, import from JSON/YAML, and export to Markdown/CSV. Code example: https://github.com/Yuri-Rassokhin/flex-cartesian/blob/main/README.md#example
Contentful API wrapper library exposing an ActiveRecord-like interface