How to move a value in a slice to the last position in Golang?

I was wondering on how to properly move a slice element to the last position of a slice in Golang.

e.g:

func main() {
	slc := []int{1,2,3,4,5}
	fmt.Println(shiftEnd(slc,2))
}

func shiftEnd(s []int, x int) []int {
return append(s[x:],s[:x]...)
}

This will result in [3,4,5,1,2] I was wondering how to receive [1,3,4,5,2].
So the received value, will be moved to the end, but the others will be kept in the same order.

Playground

Here you are, the versoin with generics. Can handle the slice of any type.

// Relocates element at s[x] to the end ov the slice.
// Modifies `s` in place
func shiftEnd[T any](s []T, x int) []T {
	if x < 0 {
		return s
	}
	if x >= len(s)-1 {
		return s
	}
	tmp := s[x]
	// No allocation since the new slice fits capacity
	s = append(s[:x], s[x+1:]...)
	// append to the end
	// no allocation, the new slice fits the capacity
	s = append(s, tmp)
	return s
}

Example: https://go.dev/play/p/J7TmafgNwm3

func main() {
	test := []int{1, 2, 3, 4, 5, 6}
	fmt.Printf("before: %#v\n", test)
	out := shiftEnd(test, 2)
	fmt.Printf("after: %#v\nresult:  %#v\n", test, out)
}

Output:

before: []int{1, 2, 3, 4, 5, 6}
after:  []int{1, 2, 4, 5, 6, 3}
result: []int{1, 2, 4, 5, 6, 3}

I was playing with this snippet solution, seems to work for what I was looking for.

func main() {
	s := []int{1, 2, 3, 4, 5}
	fmt.Println(shiftEnd(s, 2))

}

func shiftEnd(s []int, x int) []int {
	if len(s) < 1 {
		fmt.Println("No Enought Values")
		return s
	}

	if s[len(s)-1] == x {
		fmt.Println("Already in the end")
		return s
	}
	return append(append(s[:x-1], s[x:]...), x)
}

Playground

See commentary for details:

func shiftEnd(s []int, x int) []int {
	if len(s) <= 1 {
		return s
	}
	t := s[x]            // save value to move
	copy(s[x:], s[x+1:]) // shift elements down
	s[len(s)-1] = t      // set value at end
	return s
}

Use type parameters to write a function that works with any slice type:

func shiftEnd[S ~[]E, E any](s S, x int) S {
	if len(s) <= 1 {
		return s
	}
	t := s[x]            // save value to move
	copy(s[x:], s[x+1:]) // shift elements down
	s[len(s)-1] = t      // set value at end
	return s
}

https://go.dev/play/p/CSWP6_4e0Ys

I am little confused about what OP is asking because OP's answer uses x as both an element value and an element index. This answer assumes that OP intended to use x as an index only.