Add `sorted()` to Arrays / Dictionary

[Kaleb-Reid]

Describe the project you are working on

Online multiplayer survival game.

Describe the problem or limitation you are having in your project

The already existing sort() is less convenient than it should be. I find that the majority of the time I want to sort a container I am already duplicating it and maybe half of the time I will be iterating on it, but sort() only operates in-place and having no return value feels incorrect. You can't do method chaining on it and in cases it breaks the natural flow of code. Some container methods, such as filter(), map(), and slice(), return a copy whereas sort() instead operates in-place which in my opinion makes things more confusing. To add to this we already have Dictionary.merge() and Dictionary.merged() which was either a mistake or shows that there is a place for convenience methods like this in the engine.

Describe the feature / enhancement and how it helps to overcome the problem or limitation

Add a sorted() method which returns a sorted copy. This is what I would be using the majority of the time due to convenience. sort() can remain for the case where you want better performance for in-place sorting.

Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams

See godotengine/godot#112138 for an implementation. It implements sorted() for Dictionary, Array, and all of the packed arrays, and sorted_custom() to Array.

If this enhancement will not be used often, can it be worked around with a few lines of script?

I think this enhancement would be used often, but yes it could be worked around with a few lines. The point is to increase convenience by not having to write these few lines every time you want to sort.

Is there a reason why this should be core and not an add-on in the asset library?

This is about modifying a core Variant.

[Kaleb-Reid]

Related to #5771 and #6877.

[AThousandShips]

I think most cases where this would be used aren't really a problem with the workaround, saving just a single line is not very critical IMO, but it would be relevant in some specific cases where you won't actually store the copy, for example:

for i in my_array.sorted():

Where you won't ever use the sorted array directly, or if you use it as an argument to a method, though in that case it'd have to be an array you use later that shouldn't be sorted, the sorted method shouldn't be used in cases like:

var my_array := []
# Fill the array with something.
my_array.sort()
return some_other_function(my_array)

And that I feel is the problem here, the balance between convenience on the one hand and enabling or even encouraging improper use by adding a method, by making it easier to do so

Especially in more organic code where it gradually grows, for example (note that this case is obviously contrived as you would just use min):

var my_sorted_array = my_array.duplicate()
my_sorted_array.sort()
if my_sorted_array[0] == foo:
    # Do something.

If we replace that with:

if my_array.sorted()[0] == foo:
    # Do something.

And then we realize we want to check something else, or use that value again, the first case is still okay (assuming you don't forget you already had the data, and didn't mutate the original in the process)

var my_sorted_array = my_array.duplicate()
my_sorted_array.sort()
if my_sorted_array[0] == foo:
    if my_sorted_array[1] == bar:
        # Do something here.
    elif my_sorted_array[1] == baz:
        # Do something else here.

This now easily becomes:

if my_array.sorted()[0] == foo:
    if my_array.sorted()[1] == bar:
        # Do something here.
    elif my_array.sorted()[1] == baz:
        # Do something else here.

If you're not careful

I think there's also the risk that people just see people use this and think it's the correct way or the only way, or don't realize the difference and different use cases, especially since most built-in types are immutable and only have copy methods, Array, Dictionary, and Packed*Array are the only built-in types that do allow that, so someone might easily think Array and Dictionary work the same way and use this

They might see my_string = my_string.replace(a, b) or my_vector = my_vector.normalized() and think that's what should be used here as well

So I'd say the proper use for this method can easily be misunderstood and used incorrectly, it is a bit non-obvious, as it is properly used inline only when:

• The original, unsorted container is not going to be used again
• The new, sorted copy is used exactly once (exactly once here would also include where the original container is changed after the last sort, but that might also be a case where the code is written poorly and the sorted version is used too early, etc.)