proposal: slices: Use make instead of Grow in Concat

[justinhwang]

Proposal Details

slices.Concat unnecessarily uses Grow instead of make which unnecessarily increases time/op

[justinhwang]

Seeing the comment now - https://go-review.googlesource.com/c/go/+/504882#:~:text=Aug%2007%2C-,2023,-Since%20we%20don%27t

[OhJuhun]

@justinhwang
Hello. Why this issue is closed?
I think builtin make is better than slices.Grow.
Sure, in some situations slices.Grow may be more appropriate, but in this case, builtint make seems more suitable.
But in this case, slices.Grow is not better than make in terms of performance, readability, or memory allocation.
I read your discussion on PR, but I can't understand about that.
Because I think the background posting is wrong:
This code DO NOT allocate memories.

func BenchmarkSortStrings(b *testing.B) {
        s := []string{"heart", "lungs", "brain", "kidneys", "pancreas"}
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
                sort.Strings(s)
        }
}

Therefore, I believe that this post is no longer valid.

Do you understand why slices.Grow replace builtin make?
If you do, can you explain for me please?

[ianlancetaylor]

See the discussion on https://go.dev/cl/504882.

[OhJuhun]

@ianlancetaylor Thank you for your reply.
But, I already read this discussion.
"But I feel like I didn't fully understand the comment's exact meaning. I agree that there is no need to explicitly set the capacity; there is no particular reason for doing so. However, the variable name generated internally is also 'newSlices,' and the 'Grow' used in Concat always returns a slice with the size of 'size.' I believe the intent of 'Grow' is to increase the size of the provided slice, not to create a new slice. But in Concat, a new slice is being created by passing 'nil' as the original slice to 'Grow.' Considering this, I am curious if there is really a need to use 'Grow' instead of 'make' from a readability perspective. Performance also seems better when generating 'newSlices' using 'make.' I don't quite understand what issues can arise from guaranteeing the capacity. Could you please explain this in more detail? Sorry to trouble you."

[randall77]

The reason we want to round up to the next size class is to avoid reallocation on a subsequent append.

s := slices.Concat(...)
s = append(s, 7)

With make, that second line will always do a reallocation+copy. If we round up to a size class using Grow, then probably that second line will not have to do that extra work.

[OhJuhun]

@randall77
I misunderstood about slices.Grow.
I missed the comment: After Grow(n), "AT LEAST" n elements can be appended
Thank you for your reply.