To discourage people from using arrays 😉

@shusek because arrays are fixed size while Lists are not meaning that list can grow as the filter selectively adds items to the list.

Well.. Technically, as

Array.filter

creates a new

ArrayList

, it still resizes an Array, as ArrayLists are backed by Arrays

No?

it should be pre-sizing the array list to prevent expansion

You can't know ahead of time how big it will be with something like

filter

.

ah sure. missed the operator name

but that's true of any collection form so not really a reasoning one way or the other to prefer or avoid list

Well the argument is that you don't know it in advance, so you pretty much have to use an ArrayList for the resizing, at which point it doesn't make sense to do even more work and create an actual array for the result.

i think ArrayList is the right choice, but you can do less work than it will by allocating arrays in the same doubling fashion except instead of constantly copying into the new array use the last element as a pointer to the next array to form a linked list. once you're done, do a single pass of arraycopys to fill an exact-sized array. this will allocate less and copy less than ArrayList would even ignoring a final toArray call.

They should do that and return an ArrayList!

Couldn't it use a LinkedList while filtering

And allocate an ArrayList after all the filtering is done?

Would this be more efficient?

Would require a lot more allocations. Iterating through the LinkedList would be slower, since there are more nodes/references, more possible cache misses due to indirection and more space is required to hold these references.

Is there a function like

findLast

that returns the index of the object that fits a predicate?

can i get from a set to a map with a function that produces the value using something built-in? (other than

associate

which requires creating a pair)

i was hoping for something like

<K, V> Set<K>.associateValue(function: (K) -> V): Map<K, V>

We're considering something like

Iterable<K>.associateWith((K) -> V)

https://youtrack.jetbrains.com/issue/KT-13814

This might be too niche, but what about a function that returns the opposite of an intersection as a pair? Something like partition but by partitioning based on whether an element is included in the other set. Right now I'm just doing two subtraction operations.

I might be misunderstanding but isn't that

.partition { it in set }

?

no that only partitions one set. this is [1, 2, 3, 4] and [3, 4, 5, 6] becoming [1, 2] and [5, 6]

it is the subtraction of the common items from each original collection

sorry not union. intersection. it's too early 💤

I can't think of a way to actually do this more efficiently than "two subtractions"

the disjoint.

i believe disjoint implies one combined result not two

do the partition then

+

the two results?

oh but you want the pair?