`Array#forEach()` but it’s possible to define where to move to next
Iterate any iterable JS value. Works robustly in all environments, all versions.
Iterate any JS iterator. Works robustly in all environments, all versions.
A polymorphic iterate operator for arrays and other iterables
A tiny, zero-dependency yet spec-compliant asynchronous iterator polyfill/ponyfill for ReadableStreams.
A convenient way to iterate objects.
foreach component + npm package
Extended iterable class, providing lazy array-like methods with automatic async and return/throw forwarding
A tiny, faster alternative to native Array.prototype.every
Array methods for ES6 Iterators
Redact sensitive npm information from output
A dictionary of file extensions and associated module loaders.
queue-lit is a tiny queue data structure in case you `Array#push()` or `Array#shift()` on large arrays very often
A sorted list of key-value pairs in a fast, typed in-memory B+ tree with a powerful API.
Simplify your schema by combining allOf into the root schema, safely.
Iterate through the values of a stream
svg path parser
Provides tools for iterating over and manipulating GeoJSON objects.
Iterate over a collection, invoking a function for each element.
JavaScript SDK for the Seam API written in TypeScript.
Utility functions for managing data structures and measurement.
Array manipulation, ordering, searching, summarizing, etc.
A resource factory inspired by $resource from AngularJS
Iterate values in a list in random order
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.