Stupid iterator -> array function
An ESnext spec-compliant iterator helpers shim/polyfill/replacement that works as far down as ES3.
Minimal async jobs utility library, with streams support
Iterate any JS iterator. Works robustly in all environments, all versions.
AsyncIterator to Array conversion for JavaScript
Firefox 17-26 iterators throw a StopIteration object to indicate "done". This normalizes it.
Framework-independent loaders for 3D graphics formats
Get an iterator for any JS language value. Works robustly across all environments, all versions.
async.mapLimit's functionality available as a standalone npm module
Iterator abstraction based on ES6 specification
Asynchronous iterator function for parallel processing.
Higher order iterator library for JavaScript/TypeScript.
Convert an argument into a valid iterator. Based on the `.makeIterator()` implementation in mout https://github.com/mout/mout.
Iterate any iterable JS value. Works robustly in all environments, all versions.
Apply a function to a each element of a collection and return a new array of results.
No-bullshit, ultra-simple, 35-lines-of-code async parallel forEach / map function for JavaScript.
Extended iterable class, providing lazy array-like methods with automatic async and return/throw forwarding
Iterate over promises serially
Map over array avoiding parallel execution, using promises
A polymorphic iterate operator for arrays and other iterables
Map over an array or object of values in parallel or series, passing each through the async iterator, with optional lifecycle hooks.
Run multiple promise-returning & async functions with limited concurrency using native ES9
Push an array of items into an array, while being robust against prototype modification
Turn an abstract-leveldown iterator into a readable stream
This small extension to ruby's Array class provides two additional iterators, Array#each_with_floe and Array#each_with_index_floe, that simplify the reasonably-common need to specially handle "floe"--i.e., first, last, odd, even--when iterating through the elements of an array. It's particularly handy for generating CSS classes.
[1,2,3].comprehend{ |i| i.to_s if i<3 } == ["1","2"]
Just ask for the next item of a specified array. It will be persisted to a Redis DB
Provides the class IterableArray, which implements all of the methods of Array (as of Ruby 1.9.3) in an iterable-aware fashion. I.e., behavior is defined to the greatest extent possible for operations that modify an IterableArray from within an iteration block (e.g. each, map, delete_if, reverse_each). To use, call #to_iter on a pre-existing Array or use IterableArray.new; the IterableArray should act identically to a regular Array except that it responds logically to modifications during iteration.
Print progress bar for array iteration
Joins 2 or more arrays by first element into 1 long iterator
Provides iterator to iterate through nested elements of arrays and hashes.
An iterable doubly linked list which can be used as a stack, queue or array list
Reproduction methods for genetic (and other iterative improvement) algorithms, being used to solve permutation problems, where permutations are arrays of unique objects. github: https://github.com/edwardchalstrey1/pmeth
This library # This class contains all the necessary methods to do the following: -Crawl most websites and return an array of their URLS. -Convert all HTML and most web linked PDF documents to one large string given an array of urls. -Parse out all non words and non human sensible markup. -Stooge Sort an array of words via Iteration, NOT recursion. NOTE: Current verison IS using recursive stooge sort! -Write array of words to a new file.
Rize is a collection of useful methods that can make it easier to work with functions, arrays and hashes in Ruby. It allows you to compose and memoize functions, elegantly iterate over multiple arrays at once, easily map over hash keys and values, and much more. Nothing is monkeypatched, so you don't have to worry about the core classes behaving differently than you expect.
Iterate over multiple enumerators in parallel, using the external interface based on the #next method. Each call to #next returns an array, containing the next element for each of the enumerators. A StopIteration exception is raised as soon as any of the enumerators runs out of elements. SyncEnum differs from the standard library's REXML::SyncEnumerator in its use of the #next external iterator interface, while REXML::SyncEnumerator uses an #each internal iterator interface. The external interface is more convenient when you expect to end iteration before reaching the end of any of the enumerations, including cases where an enumerator generates an unending sequence.