I often want a combine(s ...[]T) function, which is helpful for this too:

combine(s[:i], v, s[j:])

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

@go101 I suggested slices.Concat during some phase of this process. :-) slices.Concat is still my preferred spelling for this. func Concat[S ~[]E, E any](dst S, slices ...S) S s = slices.Concat(s[:0], s[:i], v, s[j:])

Concat would also be able to work in place or allocating a new slice.

Given that we have Delete and Insert, Replace seems like it belongs.

It sounds like people are in favor of:

func Replace[S ~[]E, E any](s S, i, j int, v ...E) S

Based on the discussion above, this proposal seems like a likely accept.
— rsc for the proposal review group

It looks Concat gets more votes.

Should I open a separate issue for Concat?

This issue is about Replace. Feel free to open a separate issue about Concat.

Votes alone are not really the metric either - Replace fits next to the existing Insert and Delete.

No change in consensus, so accepted. 🎉
This issue now tracks the work of implementing the proposal.
— rsc for the proposal review group

Change https://go.dev/cl/444682 mentions this issue: slices: add Replace

At a glance, it looks like the implementation above could allocate twice because of the double append(). I know what append() allocates extra space, but I'm not familiar with how exactly it works, especially when appending multiple items in a single call. Are there actually any circumstances where it does two allocations?

Edit: The implementation at the time of writing:

t := s[j:]
s = append(s[:i], v...)
s = append(s, t...)
return s

Probably better to take that to the CL comments.