Construct a new enumerable wrapper.

Convert to text lines, grouped into arrays.

For large data or data that is broken into many small lines, this can improve performance over lines.

Get the first item in the sequence.

Consumes the enumeration and returns the first element.

Convert byte stream to text lines.

Important: This is a property, not a method. Use .lines not .lines().

Returns an Enumerable<string> where each item is a line of text. Lines are split on \n or \r\n. Line endings are not included in the output.

Note that this should probably only be used with small data. Consider chunkedLines to improve performance with larger data.

Implement AsyncIterable<T>.

Collect all items from this async iterable into an array.

This consumes the entire iterable and returns a Promise that resolves to an array containing all items.

Concatenate this sequence with another.

Map the sequence from one type to another, concurrently.

Results are returned in order. The order of processing is concurrent, and therefore somewhat arbitrary.

Map the sequence from one type to another, concurrently.

Items are iterated out of order. This allows maximum concurrency at all times, but the output order cannot be assumed to be the same as the input order.

This guarantees maximum concurrency whereas concurrentMap does not if the workload isn't balanced. Prefer concurrentUnorderedMap to concurrentMap for best/consistent performance.

Count the number of items; optionally with a filter.

Skip the first n items and return the rest.

Adds a counter from 0 to n-1 of the items being enumerated.

Returns tuples of [item, index] where index starts at 0.

Test if every item satisfies a condition.

Keep only items that pass a test.

Filter the sequence to exclude the items that pass a test. This returns the inverse of filter.

Find the first item that matches a condition.

Map each item to an iterable and flatten the results.

Equivalent to calling map() followed by flatten().

Flatten the iterable.

Perform an operation for each item in the sequence.

Map the iterator from one type to another.

Reduce the sequence to a single value.

Executes a reducer function on each element, passing the accumulated result from one element to the next.

Reduce the sequence to a single value with an initial value.

Run a process, piping this iterable's output to its stdin.

This allows chaining processes together like shell pipes. The current iterable's data is written to the new process's stdin, and the new process's stdout becomes the new iterable.

Run a process.

Test if any item satisfies a condition.

Take the first n items from the sequence.

Split the sequence into multiple identical streams.

Useful when you need to process the same data in different ways. Uses buffering internally, so be mindful of memory with large datasets.

Dump output to stdout. Non-locking.

Handles strings, string arrays, Uint8Arrays, and arrays of those. Strings automatically have newlines appended.

Transform the iterable from one type to another with an opportunity to catch and handle errors.

Unzip a collection of [A, B] into Enumerable<A> and Enumerable<B>.

Note that this operations uses tee, so it will use memory during the iteration.

Example

const [a, b] = enumerate([[1, "A"], [2, "B"], [3, "C"]]).unzip();

// a is number[] -> [1, 2, 3]
// b is string[] -> ["A", "B", "C"]

Dump output to a writer and close it.

This is a low-level asynchronous write of bytes without locking.

Write all data to the writer.

Example

Write some numbers to stdout.

range({to: 99})
  .map(n => n.toString())
  .transform(toBytes)
  .writeTo(Deno.stdout.writable, {noclose: true});

Zip two Enumerables together. If collections are unequal length, the longer collection is truncated.

Example

const a = range({ from: 1, until: 3 });
const b = enumerate(["A", "B", "C"]);

const result = a.zip(b);

// [[1, "A"], [2, "B"], [3, "C"]]