I would like to implement a new release using ES2015 features.

The current package just allows manipulate generators with 0-arity. There are some similar data structure in es2015: iterables

Iterables are objects that wraps a generator of 0-arity in Symbol.iterator property. Then:

• Iterum(generator) constructor will be deprecated and Iterum(iterable) will be the new constructor.
• Iterum instance will also be an iterable.
• new ES2015 Array inmutable methods will be implemented in Iterum prototype.
• Support for node >=6

Then, new branch dev-1.0 has been created and I will be happy to receive any suggestions and constributions.

Thanks.

Example:

var Iterum = require('iterum')
var Range = Iterum.Range

var it = Iterum(Range(3, 5))
var mapIt = it.map(function (value) {
    return 2 * value
})

mapIt.next() // {value: 6, done: false}
mapIt.next() // {value: 8, done: false}
it.next() // {value: 5, done: false}
it.next() // {value: undefined, done: false}

If next method of mapIt is called, next method of it is affected.

I would like to do some breaking changes.

First of all, I prefer that methods that returns lazy iterables of arrays (zip, cartesian, permutations) return iterables of iterables to achieve a real laziness. For example, is not possible to do permutations or cartesian product of potentially infinite iterables.

At second point, I want to use memoization. For example, if we have:

const iterable = Iterum([1, 2, 4, 8, 16, 32, 64, 128])

and then we need to do:

const slice = iterable.slice(6)
const result = slice.concat(slice)
[...result]

The first iterable is traversed twice.

I don't want this behaviour.

Finally, there are some methods like map, reduce, every, etc. that I would like to simplify thus:

1. removing the context parameter and,
2. Allowing the value parameter on callback functions.

The reason is that point 1 can be acomplished using bind and point 2 can be achieved using zip combined with other methods. For example:

const iterable = Iterum([1, 3, 5, 7]).map((e, i) => 2 * e + i)
// would be implemented thus:
const {range} = Iterum
const iterable = Iterum([1, 3, 5, 7]).zip(range(0, Infinity)).map(([e, i]) => 2 * e + i)

Currently, iterum library use functions inspired by lodash. However, after reading more about functional programming and knowing another libraries like imlazy, ramda or lodash/fp, I prefer iterables in the last parameter.

Now, cartesian method does not allow to be used with infinite iterables. If cartesian returns an iterable of iterables, this method will be able to be lazy.

includes and indexOf has fromIndex arguments which don't make sense.

In Array approach it is useful to have better performance. But in lazy approach doing iterum.drop(fromIndex).includes(...) is the same.

If a groupBy method returns a lazy iterable of lazy iterables, it is possible call this method on potentially infinite iterable:

range(0, Infinity).groupBy(e => e % 5) /* [
    [0, 5, 10, ... ],
    [1, 6, 11, ... ],
    [2, 7, 12, ... ],
    ...
]

I found es-iter library that implements similar methods to this library. But there are mutables. For example:

const Iter = require('es-iter')
var a = new Iter([1, 2, 3])
var b = a.map(e => 2 * e)
[...a] // returns [1, 2, 3]
[...b] // however it returns [] because has been consumed previously

However, I found some performance problems in Iterum#cartesian method vs Iter#product method. When a cartesian product of large number of iterables is calculated, it takes a lot of time:

I will try to solve this issue.

https://jsperf.com/iterum-vs-es-iter-cartesian-product

I would like to implement a method that returns the combinations of n values that produces an iterable. For example:

Iterum([1, 2, 3, 4]).combinations(2) /*
    (1 2)
    (1 3)
    (1 4)
    (2 3)
    (2 4)
    (3 4)
) */

I don't know what is the best order to produce values yet

All methods except build and toArray (and forEach?) should return Iterum instances. .every, .indexOf, .reduce, .reduceRight and .some that return other type of values. They should return a generator that builds an iterator with one iteration with the same value that returns in [email protected]

• add Cartesian constructor
• add How to customize Iterum build (just import what you need!).
• change from value methods/transform methods to eager methods/lazy methods