[RFC] [Discussion] Add new function `array_group`

1. The grouping that JavaScript/.NET/Lodash/Scala/etc. do (this should
   be the default of array_group)
2. The grouping that Haskell does, the one I proposed earlier (this can
   be altered in a flag within array_group)

Based on this, I'd like to adjust my initial proposal, where we would
have the following function: function array_group(array $array, callable $callback, bool $consecutive_pairs = false): array {}

If the argument consecutive_pairs is false, it will use the
function's return value to do the grouping ($callback accepting single
element in this case)
Otherwise, it will use the function's boolean return value to check if
two consecutive elements need to be grouped ($callback accepting two
elements in this case)

(This approach seems to be consistent with array_filter in the sense
the callback accepts one or two arguments)

With a few example usages:

var_dump( array_group($arr1, function( $x ) {
return (string) strlen( $x );
} ) );
// Producing ['3' => ['one', 'two'], '5' => ['three']]

Another one:

$arr = [-1,2,-3,-4,2,1,2,-3,1,1,2];

$groups = array_group( $arr, function( $p1, $p2 ) {
 return ($p1 > 0) == ($p2 > 0);
} );
// Producing [[-1],[2],[-3,-4],[2,1,2],[-3],[1,1,2]]

This sounds like two separate functions in a trenchcoat. It should be two separate functions.

I believe this proposal captures many use cases, beyond the examples we
discussed. Curious about any other thoughts.

I'm also attaching a PoC patch that implements this.

Attachments:

• array_group.patch

Side note: I don't think anyone reads patches sent to the list. I didn't even realize it allowed attachments. :-) If you want someone to review code, a GitHub PR is the way to go.

You can also include benchmarks there. From experience, if you don't have a compelling reason why this needs to be in C rather than PHP (which in this case boils down to performance exclusively), you're not going to be able to convince people to add another random utility function. That's just the reality these days.

--Larry Garfield

--

To unsubscribe, visit: https://www.php.net/unsub.php

Thank you for your thoughts. We can definitely separate them in two functions. Also thanks on the note for the patches - will keep it in mind :)

Good point on the benchmarks, I will keep those in mind.

Beyond performance, I think this has to do with developer experience pretty much, too. Almost all mainstream languages have a built-in grouping function, and in my honest opinion, it's time PHP has one too :) I think we can all agree grouping is a very common/basic functionality that we all meet with regularly.

Here we go,
https://3v4l.org/KsL3o

function array_group(array $arr1, callable $compare): array {
$groups = [];
$group = [];
$prev = NULL;
foreach ($arr1 as $value) {
if ($group && !$compare($prev, $value)) {
$groups[] = $group;
$group = [];
}
$group[] = $value;
$prev = $value;
}
if ($group) {
$groups[] = $group;
}
return $groups;
}

Thank you, this clarifies and it confirms my initial assumption of
what you are proposing.
So you want to slice an array by comparing adjacent values.

My personal feedback:
I think the need for the grouping behavior you describe is not common
enough that it needs its own native function.
I would say the more common desired behavior is the one in your first
example. And even for that we don't have a native function.

Your behavior can be implemented in userland like so:
https://3v4l.org/epvHm

$arr1 = array(1,2,2,3,1,2,0,4,5,2);

$groups = [];
$group = [];
$prev = NULL;
foreach ($arr1 as $value) {
if ($group && $prev > $value) {
$groups[] = $group;
$group = [];
}
$group[] = $value;
$prev = $value;
}
if ($group) {
$groups[] = $group;
}

print_r($groups);

If needed, the comparison function can be separated out and passed as
a parameter.
So the array_group() function with a comparison callback parameter can
be implemented in userland.

I think you need to make a case as to why the behavior you describe
justifies a native function.
E.g. if you find a lot of public php code that does this kind of grouping.

I personally suspect it is not that common.

Cheers
Andreas

Hey,

Thanks for the suggestion.

For the previous case in the code, I added these in a Gist to not clutter here too much:

1. The first example corresponds to https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_manual_group-php
2. The second example corresponds to https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_array_group-php
3. Another example, addressing the problem of increasing subsequences is very simple with array_group: https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_array_incr_subseqs-php

Best,

Boro

Hello Boro,
I think you should include the "expected result" in your code examples.
Maybe this is in your patch file, but I don't think we want to look at
that for discussion.

Cheers
Andreas

Hello all,

As per the How To Create an RFC instructions, I am sending this e-mail in order to get your feedback on my proposal.

I propose introducing a function to PHP core named array_group. This function takes an array and a function and returns an array that contains arrays - groups of consecutive elements. This is very similar to Haskell's groupBy function.

For some background as to why - usually, when people want to do grouping in PHP, they use hash maps, so something like:

<?php
$array = [
[ 'id' => 1, 'value' => 'foo' ],
[ 'id' => 1, 'value' => 'bar' ],
[ 'id' => 2, 'value' => 'baz' ],
];

$groups = [];
foreach ( $array as $element ) {
   $groups[ $element['id'] ][] = $element;
}

var_dump( $groups );

This can now be achieved as follows (not preserving keys):

<?php
$array = [
[ 'id' => 1, 'value' => 'foo' ],
[ 'id' => 1, 'value' => 'bar' ],
[ 'id' => 2, 'value' => 'baz' ],
];

$groups = array_group( $array, function( $a, $b ) {
return $a['id'] == $b['id'];
} );

The disadvantage of the first approach is that we are only limited to using equality check, and we cannot group by, say, < or other functions.
Similarly, the advantage of the first approach is that the keys are preserved, and elements needn't be consecutive.

In any case, I think a utility function such as array_group will be widely useful.

Please find attached a patch with a proposed implementation. Curious about your feedback.

Best,

Boro Sitnikovski

Hi,

Thank you for your thoughts.

I would say the more common desired behavior is the one in your first
example. And even for that we don't have a native function.

This Google search might give more insight into the number of discussions about a grouping functionality: https://www.google.com/search?q=php+group+elements+site:stackoverflow.com

Your behavior can be implemented in userland like so:
https://3v4l.org/epvHm

Correct, but then again, we can also implement array_map/array_filter/etc. in userland :)

I think you need to make a case as to why the behavior you describe
justifies a native function.

Similar to my previous answer, but also in general - ease of access and also performance.

E.g. if you find a lot of public php code that does this kind of grouping.

I personally suspect it is not that common.

Cheers
Andreas

Hey,

Thanks for the suggestion.

For the previous case in the code, I added these in a Gist to not clutter here too much:

1. The first example corresponds to https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_manual_group-php
2. The second example corresponds to https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_array_group-php
3. Another example, addressing the problem of increasing subsequences is very simple with array_group: https://gist.github.com/bor0/b5f449bfe85440d96abd933b9f03b310#file-test_array_incr_subseqs-php

Best,

Boro

Hello Boro,
I think you should include the "expected result" in your code examples.
Maybe this is in your patch file, but I don't think we want to look at
that for discussion.

Cheers
Andreas

Hello all,

As per the How To Create an RFC instructions, I am sending this e-mail in order to get your feedback on my proposal.

I propose introducing a function to PHP core named array_group. This function takes an array and a function and returns an array that contains arrays - groups of consecutive elements. This is very similar to Haskell's groupBy function.

For some background as to why - usually, when people want to do grouping in PHP, they use hash maps, so something like:

<?php
$array = [
[ 'id' => 1, 'value' => 'foo' ],
[ 'id' => 1, 'value' => 'bar' ],
[ 'id' => 2, 'value' => 'baz' ],
];

$groups = [];
foreach ( $array as $element ) {
  $groups[ $element['id'] ][] = $element;
}

var_dump( $groups );

This can now be achieved as follows (not preserving keys):

<?php
$array = [
[ 'id' => 1, 'value' => 'foo' ],
[ 'id' => 1, 'value' => 'bar' ],
[ 'id' => 2, 'value' => 'baz' ],
];

$groups = array_group( $array, function( $a, $b ) {
return $a['id'] == $b['id'];
} );

The disadvantage of the first approach is that we are only limited to using equality check, and we cannot group by, say, < or other functions.
Similarly, the advantage of the first approach is that the keys are preserved, and elements needn't be consecutive.

In any case, I think a utility function such as array_group will be widely useful.

Please find attached a patch with a proposed implementation. Curious about your feedback.

Best,

Boro Sitnikovski

Thank you for the information and encouragement! I was a bit scared of this one being rejected too, but still decided to give it a shot :)

As an alternative approach this is what I would do in your situation:

I would start with a PHP implementation, gather some opinions on what this method would do, how it should work. Finalising the functional specification to a point where you find broad acceptance. This would also allow others to help performance optimise your implementation.

Then start a PECL extension implementing the exact same thing in C code. This could start as a niche for people that really need the extra performance the extension would bring, possibly grow out to something that is defacto standaard.

PECL extensions are documented in the PHP manual, so the manual could have your array_group() function described, possibly with a reference to the original PHP implementation/ polyfill.

This approach minimises dependence on internals giving a green light and maximises the possibility to work with others as a team on this. It would give you a chance to prove that the solution you provide is actually wanted by users. If that really is the case, if it came to vote to merging the extension into PHP itself the vote could be different than the vote on the former RFC.

Greetings, Casper

Thank you for the suggestion, I like this approach and it's definitely much "safer" than going with an RFC for core directly.

What are your thoughts on creating a PECL extension called array_utils (selling point would be high performance array utils or something), which in the future might contain more than array_group*, and the approach would be to cherry-pick those functions that have frequent usage in codebases into core? Or would it be better to stick to a particular/more concrete extension?