`ArrayList().shrinkAndFree` asserts length instead of capacity about zig HOT 4 OPEN

Okay, yeah; I think there's a reasonable case to be made for a shrinkCapacity function, maybe something like this:

/// If the capacity exceeds the given limit, resizes the allocated buffer to exactly that limit.
/// Asserts that the given limit is at least the length of the `ArrayList`.
/// Invalidates all element pointers.
pub fn shrinkCapacity(self: *Self, limit: usize) Allocator.Error!void {
    assert(limit >= self.items.len);
    if (self.capacity <= limit) return;
    const allocator = self.allocator;
    if (allocator.resize(self.allocatedSlice(), limit)) {
        self.capacity = limit;
        return;
    }
    const new_memory = try allocator.alignedAlloc(T, alignment, limit);
    @memcpy(new_memory[0..self.items.len], self.items);
    allocator.free(self.items);
    self.items = new_memory;
    self.capacity = limit;
}

from zig.

This is working as designed. If you want to see this behavior changed, that is a proposal. Realistically, if we want to have this function, it should be under a different name, since the function you are describing does not shrink the ArrayList.

Could I ask what scenario have you encountered where you have an ArrayList which:

• Has current length X
• Needs capacity Y > X
• Should not have a capacity greater than Y?

from zig.

Could I ask what scenario have you encountered where you have an ArrayList

Here is the motivating commit: oven-sh/bun@57dcdbf#diff-dde34f421656d5d1df29476c8c358985d1b22bae2c505c70e0f3d922e0af9fe5R383-R388

This is in the code in Bun which writes to a pipe or file streaming (for use from JavaScript).

The usecase: you're using an ArrayList as a growable buffer that is reused repeatedly. The ArrayList is a dynamic allocation. At first, it's growing and growing. Later, you finish writing but you don't want to pay the cost of re-allocating to shrink it unless that allocation gets big enough to "matter". But at that point, the capacity of the list might've grown a lot but you might only be using a small part of it.

from zig.

Side note: shrinkCapacity is very close to what toOwnedSlice wants to do as well, so toOwnedSlice could likely be made to use a shrinkCapacity function.

from zig.