Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:125821
Message-ID: <19897c07-ebc8-49e8-9825-30a3fcc00a3e@varteg.nz>
Date: Mon, 21 Oct 2024 21:04:42 +1300
Precedence: bulk
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PHP-DEV] [RFC] Change behaviour of array sort functions to
 return a copy of the sorted array
To: internals@lists.php.net
References: <ZydAaayECTRNG8Ackhb0tDgYjmdFKnkW4p0ISWlLFP5My4CsJBR1KKTylrD14Ags2GUyBLoJPf68N6Z6LoVzjG-tru8YAbmi74W5xzSkJ8I=@gpb.moe>
Content-Language: en-GB
In-Reply-To: <ZydAaayECTRNG8Ackhb0tDgYjmdFKnkW4p0ISWlLFP5My4CsJBR1KKTylrD14Ags2GUyBLoJPf68N6Z6LoVzjG-tru8YAbmi74W5xzSkJ8I=@gpb.moe>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
From: weedpacket@varteg.nz (Morgan)

On 2024-10-21 06:42, Gina P. Banyard wrote:
> Hello internals,
> 
> I would like to propose a short RFC to make the return value of the sort() and similar functions more useful:
> https://wiki.php.net/rfc/array-sort-return-array
> 
> I intend for the discussion to last 2 weeks and then open the vote.
> 
> Best regards,
> 
> Gina P. Banyard
I've been working up something very much similar so I'd be well behind this.

My thinking ended up the same as Larry Garfield's:

 > *sorted($arr) seems like it would be a lot less confusing, and 
consistent with what other languages (and hopefully future PHP) do.  (I 
don't know what that means for array_walk(), but I don't know what that 
would even return anyway.)

Making it a new function instead of changing the existing function would 
be less of a break it seems.


Excerpts from my drafts:

All of the functions [the thirteen array sorting functions, including 
shuffle()] have the less-than-informative return type of `true` (except 
`array_multisort()` with its more complex argument requirements and 
hence the ability to also return `false`). All of their behaviour is by 
reference. Oh, except when they flat-out fail, in which case they return 
null.

This means that if you want to sort an array you have to have an entire 
statement devoted to the task. As an expression, `sort()` just doesn’t 
compose: you can’t sensibly use it anywhere as part of a larger expression.
You have to write:
	$escaped = $array->valued($expression);
	sort($escaped);
	$escaped = array_map(escape(...), $escaped);
because
	$escaped = array_map(escape(...), sort($array->valued($expression));
simply won’t work.
It gets in the way when using it as a callback in array functions. You 
can’t use:
	$sorted_datasets = array_map(sort(...), $datasets);
You want
	$sorted_datasets = $datasets;
	array_walk($sorted_datasets, sort(...));
`array_walk()` is the only built-in array function using callbacks that 
can meaningfully accept `sort()` (even the `array_walk_recursive()` 
variant will recurse into child arrays instead of sorting them). Because 
`array_walk()` iterates through the array by reference as well, it too 
interrupts functional composition, as just shown above. But at least it 
can often be replaced by `array_map()` (just look at the number of user 
notes on its manual page that suggest using references to make it behave 
more that way). `array_walk()` is basically for the case where there is 
no useful value to return from traversing the array (good thing, too, 
since its return type is `true`). But I digress.

...

The name `sorted()` has already been introduced. The `-ed` suffix can be 
grammatically applied to all of the sorting functions (technically for 
`shuffle()` the suffix would be `-d` because the `e` is already there). 
But that is just the one I came up with.
What we don’t want is Yet Another Prefix to go into the alphabet soup 
that is `([ak]?r?|u[ak]?|nat(case)?)`. “Hey, how about we use ‘f’ as a 
prefix meaning ‘functional’?” “Do you want to be responsible for 
prefixing ‘uksort’ with an ‘f’?”
At the same time we don’t want any modification that would make the name 
clunky to use. Not everything should be reliant on IDE autocompletion.

...

Most languages in widespread use do operate on their arrays in place, 
but in those cases the arrays are object types and sorting is an 
instance method performed on and modifying the object. That’s not how 
PHP models arrays. Functional languages meanwhile have – by definition – 
functional sort functions.
One notable example is Python, in which lists have an in-place `.sort()` 
method. The language however also offers a global `sorted()` function, 
which takes a list and returns a new, sorted one, pretty much like what 
is proposed here, and for pretty much the same reason: it is more easily 
composable with other operations.

...

It would impact anyone (such as myself) who already defines global 
functions named `sorted()`. In my case it’s precisely so that I can have 
such functional sort functions. It’s not unlikely that there are 
functions with that name that have other jobs (e.g. a `sorted` that 
tests whether a list is sorted) and would need to be renamed (e.g. to 
`is_sorted`). But adding any functions to core would mean renaming 
existing global user functions that currently have the same names 
regardless of what they are for. A quick github search turned up a 
number of `sorted` global functions, some of them exactly matching the 
userland implementation above; and all (from the sample I took) looking 
like the intent is to take an array (by value) or something that is 
queried for an array, sort it in some way, and return the result. In 
other words, passing the array to be sorted by value and returning the 
sorted array is the more common idiom.

[The userland implementation mentioned being

function sorted(array $array): array
	{
		sort($array);
		return $array;
	}

]