lazily-evaluated chainable generator methods, providing near feature parity with the Array API
The iterable toolbox
Define a lazily evaluated property on an object
Lazy assertions without performance penalty
Fun with Iterables
The iterable toolbox
Cache requires to be lazy-loaded when needed.
Lazy value.
Import a module lazily
Basic operations on iterables
Lazy lists for node
A streaming data transport format that aims to support built-in features such as Promises, Dates, RegExps, Maps, Sets and more.
immutable iterator that supports lazy evaluation and chain methods
React Component to lazy load images using a HOC to track window scroll position.
Build chainable fluent interfaces the easy way... with a freakin' chainsaw!
Higher order iterator library for JavaScript/TypeScript.
Open Node Streams on demand.
Core types for paging async iterable iterators
Robust Environment Configuration for Universal Applications.
Standard iterator utilities.
Transforming XML to JSON using Node.js binding to native pugixml parser library
Coherent, zero-dependency, lazy, simple, GraphQL over WebSocket Protocol compliant server and client
parseArgs tokens compatibility and more high-performance parser
Simple lazy loading component built with react
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