obliterator

What is obliterator?

The 'obliterator' npm package provides a set of utilities for working with iterables and iterators in JavaScript. It offers a variety of functions to manipulate, transform, and handle iterables efficiently.

What are obliterator's main functionalities?

Iterate

The 'iterate' function allows you to create an iterator from an iterable object like an array. This example demonstrates how to iterate over an array using the iterator's next() method.

const iterate = require('obliterator/iterate');
const array = [1, 2, 3, 4];
const iterator = iterate(array);
let result = iterator.next();
while (!result.done) {
  console.log(result.value);
  result = iterator.next();
}

Range

The 'range' function generates an iterator that produces numbers within a specified range. This example shows how to create an iterator that yields numbers from 1 to 4.

const range = require('obliterator/range');
const iterator = range(1, 5);
let result = iterator.next();
while (!result.done) {
  console.log(result.value);
  result = iterator.next();
}

Take

The 'take' function allows you to take a specified number of elements from an iterable. This example demonstrates how to take the first 3 elements from an array.

const take = require('obliterator/take');
const array = [1, 2, 3, 4, 5];
const result = take(array, 3);
console.log(result); // [1, 2, 3]

Filter

The 'filter' function creates an iterator that yields only the elements that satisfy a given predicate. This example shows how to filter out odd numbers from an array.

const filter = require('obliterator/filter');
const array = [1, 2, 3, 4, 5];
const iterator = filter(array, x => x % 2 === 0);
let result = iterator.next();
while (!result.done) {
  console.log(result.value);
  result = iterator.next();
}

Other packages similar to obliterator

iter-tools

The 'iter-tools' package provides a comprehensive set of utilities for working with iterables and iterators. It offers a wide range of functions for transforming, filtering, and combining iterables, similar to 'obliterator'. However, 'iter-tools' has a larger set of features and more extensive documentation.

lazy.js

The 'lazy.js' package is a utility library for working with lazy sequences. It allows you to create and manipulate sequences in a lazy manner, meaning computations are deferred until necessary. While 'lazy.js' offers similar functionalities to 'obliterator', it focuses more on lazy evaluation and chaining operations.

lodash

The 'lodash' package is a popular utility library that provides a wide range of functions for manipulating arrays, objects, and other data structures. Although 'lodash' is not specifically focused on iterables and iterators, it offers many similar functions for transforming and filtering data.

README

Obliterator

Obliterator is a dead simple JavaScript library providing miscellaneous higher-order iterator functions such as combining two or more iterators into a single one.

Installation

npm install --save obliterator

Usage

Summary

Classes

• Iterator

Functions

• chain
• combinations
• consume
• filter
• forEach
• map
• match
• permutations
• powerSet
• split

Iterator

A handy Iterator class with safeguards and usable with ES2015's for ... of loop constructs & spread operator.

import Iterator from 'obliterator/iterator';
// Or
import {Iterator} from 'obliterator';

const iterator = new Iterator(function() {
  // Define what the `next` function does
});

// Checking that the given value is an iterator (native or else)
Iterator.is(value);

// Creating an empty iterator
const emptyIterator = Iterator.empty();

// Creating a simple iterator from a single value
const simpleIterator = Iterator.of(34);

chain

Variadic function chaining all the given iterators.

import chain from 'obliterator/chain';
// Or
import {chain} from 'obliterator';

const set1 = new Set('a');
const set2 = new Set('bc');

const chained = chain(set1.values(), set2.values());

chained.next();
>>> {done: false, value: 'a'}
chained.next();
>>> {done: false, value: 'b'}

combinations

Returns an iterator of combinations of the given array and of the given size.

Note that for performance reasons, the yielded combination is always the same object.

import combinations from 'obliterator/combinations';
// Or
import {combinations} from 'obliterator';

const iterator = combinations(['A', 'B', 'C', 'D'], 2);

iterator.next().value;
>>> ['A', 'B']
iterator.next().value;
>>> ['A', 'C']

consume

Function consuming the given iterator and returning its values in an array.

import consume from 'obliterator/consume';
// Or
import {consume} from 'obliterator';

const set = new Set([1, 2, 3]);

consume(set.values());
>>> [1, 2, 3]

filter

Function returning an iterator filtering another one's values using the given predicate.

import filter from 'obliterator/filter';
// Or
import {filter} from 'obliterator';

const set = new Set([1, 2, 3, 4, 5]);

const even = x => x % 2 === 0;

const iterator = filter(even, set.values());

iterator.next().value
>>> 2
iterator.next().value
>>> 4

forEach

Helper function that can be used to iterate easily over the given iterator.

import forEach from 'obliterator/foreach';
// Or
import {forEach} from 'obliterator';

const set = new Set(['apple', 'banana']);

forEach(set.values(), (value, i) => {
  console.log(i, value);
});

map

Function returning an iterator mapping another one's values using the given function.

import map from 'obliterator/map';
// Or
import {map} from 'obliterator';

const set = new Set([1, 2, 3, 4, 5]);

const triple = x => x * 3;

const iterator = map(triple, set.values());

iterator.next().value
>>> 3
iterator.next().value
>>> 6

match

Function returning an iterator over the matches of a given regex applied to the target string.

import match from 'obliterator/match';
// Or
import {match} from 'obliterator';

const iterator = match(/t/, 'test');

iterator.next().value.index
>>> 0
iterator.next().value.index
>>> 3

permutations

Returns an iterator of permutations of the given array and of the given size.

Note that for performance reasons, the yielded permutation is always the same object.

import permutations from 'obliterator/permutations';
// Or
import {permutations} from 'obliterator';

let iterator = permutations([1, 2, 3]);

iterator.next().value
>>> [1, 2, 3]
iterator.next().value
>>> [1, 3, 2]

iterator = permutations(['A', 'B', 'C', 'D'], 2);

iterator.next().value;
>>> ['A', 'B']
iterator.next().value;
>>> ['A', 'C']

powerSet

Returns an iterator of sets composing the power set of the given array.

import powerSet from 'obliterator/power-set';
// Or
import {powerSet} from 'obliterator';

const iterator = powerSet(['A', 'B', 'C']);

iterator.next().value;
>>> []
iterator.next().value;
>>> ['A']

split

Returns an iterator over the splits of the target string, according to the given RegExp pattern.

import split from 'obliterator/split';
// Or
import {split} from 'obliterator';

const iterator = split(/;/g, 'hello;world;super');

iterator.next().value;
>>> 'hello'
iterator.next().value;
>>> 'world'

Contribution

Contributions are obviously welcome. Please be sure to lint the code & add the relevant unit tests before submitting any PR.

git clone [e-mail]:Yomguithereal/obliterator.git
cd obliterator
npm install

# To lint the code
npm run lint

# To run the unit tests
npm test

License

MIT