proposal: x/exp/slices: add Pop

[thatradius]

// Pop removes the elements s[i] from s, returning the modified slice
// and the removed element. Pop panics if s[i] is not a valid slice of s.
func Pop[S ~[]E, E any](s S, i int) (S, E) {
	e := s[i]
	return append(s[:i], s[i+1:]...), e
}

[ianlancetaylor]

Can you write a doc comment for the proposed function? Specifically, what happens when the slice is empty.

Seems odd to have Pop without Push.

[thatradius]

@ianlancetaylor Like Delete but returns the removed element.

[thatradius]

About Push maybe just like this.

// Push appends the element at s[:i], returning the modified slice.
func Push[S ~[]E, E any](s S, i int, e E) S {
	return append(append(s[:i], e), s[i+1:]...)
}

[seankhliao]

That Push is the same as Insert

Push/Pop seems like a strange name for the given actions, usually they mean operating at the ends of a queue

[thatradius]

Maybe change the method name to Remove like Rust's vector?

[DeedleFake]

I agree that Pop is a strange name for it, but Remove for parity with Insert makes sense to me.

[thatradius]

What about this?

// Pop removes the element s[i] from s, returning the modified slice
// and the removed element. Pop panics if i is not valid index of s.
func Pop[S ~[]E, E any](s S, i int) (S, E) {
	switch i {
	case 0:
		return s[1:], s[0]
	case len(s) - 1:
		return s[:len(s)-1], s[len(s)-1]
	}
	return append(s[:i], s[i+1:]...), s[i]
}

// Remove removes the elements s[i:j] from s, returning the modified slice
// and the removed elements. Remove panics if s[i:j] is not a valid slice of s.
func Remove[S ~[]E, E any](s S, i, j int) (S, S) {
	var s2 S
	if n := j - i; cap(s) >= len(s)+n {
		// Use the free space to avoid an allocation.
		s2 = s[len(s) : len(s)+n]
	} else {
		s2 = make(S, n)
	}
	copy(s2, s[i:j])
	return append(s[:i], s[j:]...), s2
}

[earthboundkid]

Python has dict.pop which works like this. I don't think this behavior really makes sense for a slice though. It's not a very substantial savings versus just doing:

e := s[i]
s = slices.Delete(s, i, i+1)

It saves you a line, but it adds noise to the docs and open questions about behavior, when really we should be discouraging using O(N) operations more than necessary.

[rsc]

Pop should not be an O(N) operation. Saving s[i] and calling Delete seems fine for this use case. Delete is a bit problematic already; better not to have two.