I was expecting slice() to not iterate further if its limit value is 1 and it already found a value.

I have added a failing test for if this really is undesired behavior.

I'd like to release version 2.0 with PHP version requirement bumped to 7.1 and added type hints.

Are there any other (breaking) changes that should be done now?

• Added the associate function to inverse enumerate

A good example of where this would be useful is if you need to map over the keys and values at the same time:

$dict = [
    'a' => 1,
    'b' => 2,
    'c' => 3,
];
iter\associate(iter\map(function($tup) {
      return [strtoupper($tup[0], $tup[1] * 2];
}, iter\enumerate($dict));
// iter('A' => 2, 'B' => 4, 'C' => 6)

Basically, it provides a much cleaner way to un-enumerate an iterable.

Implementation of a product generator function, that returns the cartesian product of 0 or more iterators. The key is a tuple of the iteratables keys, and the value a tuple of the iterables values.

Example:

// Returns [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5]]
toArray(product([1, 2], [3, 4, 5]));

Is there any reason for not passing both key and value to the mapKeys and map functions?

I find myself often wanting to use both even when just changing one.

Currently one option is to use enumerate, but it makes the code a lot longer than it needs to be.

Takes an iterable and chunks it into the specified size.

This function is lazy in that it yields each chunk as a generator which when iterated will yield size times or until the iterator is no longer valid

Examples:

  iter\chunk([1, 2, 3], 2)
  => iter(iter(1, 2), iter(3))

These two solve a use case which i often have.

You have a nested associative array like this:

$securities = [
    [
        'seccode' => 'HT-R-A',
        'isin' => 'HRHT00RA0005',
        'issuer' => [
            'code' => 'HT',
            'name' => 'Hrvatski Telekom d.d.'
        ],
    ],
    [
        'seccode' => 'INGR-O-11CA',
        'isin' => 'HRINGRO11CA1',
        'issuer' => [
            'code' => 'INGR',
            'name' => 'Ingra d.d.'
        ],
    ]
];

And you want to iterate over it, but with the key being a value from the array.

$path = iter\fn\path('issuer', 'code');
$iter = iter\reindex($securities, $path);
foreach(iter\keys($iter) as $key) {
    var_dump($key);
}

This yields:

string(2) "HT"
string(4) "INGR"

A run on PHP 8.1 currently shows:

PHP Deprecated:  Return type of iter\rewindable\_RewindableGenerator::current() should either be compatible with Iterator::current(): mixed, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/src/iter.rewindable.php on line 123
PHP Deprecated:  Return type of iter\rewindable\_RewindableGenerator::next() should either be compatible with Iterator::next(): void, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/src/iter.rewindable.php on line 108
PHP Deprecated:  Return type of iter\rewindable\_RewindableGenerator::key() should either be compatible with Iterator::key(): mixed, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/src/iter.rewindable.php on line 118
PHP Deprecated:  Return type of iter\rewindable\_RewindableGenerator::valid() should either be compatible with Iterator::valid(): bool, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/src/iter.rewindable.php on line 113
PHP Deprecated:  Return type of iter\rewindable\_RewindableGenerator::rewind() should either be compatible with Iterator::rewind(): void, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/src/iter.rewindable.php on line 103
PHP Deprecated:  Return type of iter\_CountableTestDummy::count() should either be compatible with Countable::count(): int, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/runner/work/iter/iter/test/iterTest.php on line 625

These deprecation notices relate to the Return types for internal methods RFC in PHP 8.1.

Using the attribute will silence the deprecation notices for now for those methods for which it cannot be added yet (PHP 8.0 mixed). For all other methods, the return type has now been added.

#64 caught my eye. I noticed that changing how the existing methods worked would cause issues, so I made a new mapWithKeys() method that passes the iterator key in addition to its value to the callback.

Here is a copy/paste of the test I wrote for it, to see it in action:

$mapped = mapWithKeys(func\operator('*'), range(0, 5));
$this->assertSame([0, 1, 4, 9, 16, 25], toArray($mapped));

$mapped = mapWithKeys(
    function ($v, $k) { return sprintf('%s%s', $k, $v); },
    ['foo' => 'bar', 'bing' => 'baz']
);
$this->assertSame(
    ['foo' => 'foobar', 'bing' => 'bingbaz'],
    toArrayWithKeys($mapped)
);

Similar to the iter\flatten, except it flattens by 1 step. This is very useful in many areas where your generators are yielding arrays and you want that to be unit of data to work with.

Here's an implementation:

function concat ($iterable) {
    return iter\reduce(
        function ($chainedIterables, $nextIterable) {
            return iter\chain($chainedIterables, $nextIterable);
        },
        $iterable,
        []
    );
}

This should be equivalent to a foldl concat implementation in Haskell.

I think will be better if developers will be able to get a key.

Example:

use iter as f;

f\reduce(function ($acc, $value, $key) {
    $acc .= sprintf("%s: %s\n", $key, $value);
    return $acc;
}, $response->headers->all(), '');

Or I can do it otherwise?

One super common use case is finding the index at which you need to insert something into an array.

Built-in array_search() does this if you are looking for an element by exact value or identity. What is dearly missing is a function that returns the key of the first element that matches a user-defined predicate. While it is trivial to write a simple loop, the frequency with which this is needed (particularly when writing complex refactorings using nikic/php-parser) adds up to some cognitive load. It would be great to have a function that DoesJustThat™, and as part of a widely used library too, rather than as a copypaste in every project's myfuncs.php.

The return type of IteratorAggregate::getIterator is Traversable, but toIter assumes the value returned will be of type Iterator. The return type check on toIter therefore fails when getIterator returns another IteratorAggregate.

I don't know if it would be relevant or not. Some benchmark might be required to determine whether or not the original json_encode would fail on big arrays with big objects. If so using iterators could become useful. Comparing to the original one there would be the need for special const such as FORCE_OBJECT(which already exists) and a FORCE_LIST

We have a use case where we need to get a value by its index.

In that sense, I'd like to suggest introducing a function at/get(iterable $iterable, int $index) : ?int that takes an iterable and returns the item at the specified index.

I'll be glad to provide a PR if welcome.