Moving an slice item from one position to another in go

I' trying to move an item from one position to another inside a slice. Go Playground

indexToRemove := 1
indexWhereToInsert := 4
    
slice := []int{0,1,2,3,4,5,6,7,8,9}    
    
slice = append(slice[:indexToRemove], slice[indexToRemove+1:]...)
fmt.Println("slice:", slice)    
    
newSlice := append(slice[:indexWhereToInsert], 1)
fmt.Println("newSlice:", newSlice)
    
slice = append(newSlice, slice[indexWhereToInsert:]...)
fmt.Println("slice:", slice)

This produces to following output:

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 1 6 7 8 9] 

But I would expect the output be like this:

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 **5** 6 7 8 9] 

Where is my fault?

I had the same issue before and I solved as:

func insertInt(array []int, value int, index int) []int {
	return append(array[:index], append([]int{value}, array[index:]...)...)
}

func removeInt(array []int, index int) []int {
	return append(array[:index], array[index+1:]...)
}
	
func moveInt(array []int, srcIndex int, dstIndex int) []int {
	value := array[srcIndex]
	return insertInt(removeInt(array, srcIndex), value, dstIndex)
}


func main() {
	slice := []int{0,1,2,3,4,5,6,7,8,9}
	
	fmt.Println("slice: ", slice)

	slice = insertInt(slice, 2, 5)	
	fmt.Println("slice: ", slice)
		
	slice = removeInt(slice, 5)	
	fmt.Println("slice: ", slice)
		
	slice = moveInt(slice, 1, 4) 
	fmt.Println("slice: ", slice)
}

https://play.golang.org/p/Sfu1VsySieS

The problem is that newSlice is not a distinct copy of slice--they reference the same underlying array.

So when you assign to newSlice, you're modifying the underlying array, and thus slice, too.

To remedy this, you need to make an explicit copy:

Playground

package main

import (
	"fmt"
)

func main() {

	indexToRemove := 1
	indexWhereToInsert := 4
	
	slice := []int{0,1,2,3,4,5,6,7,8,9}
	
	val := slice[indexToRemove]
	
	slice = append(slice[:indexToRemove], slice[indexToRemove+1:]...)
	fmt.Println("slice:", slice)	
	
	newSlice := make([]int, indexWhereToInsert+1)
	copy(newSlice,slice[:indexWhereToInsert])
	newSlice[indexWhereToInsert]=val
	fmt.Println("newSlice:", newSlice)
	fmt.Println("slice:", slice)
	
	slice = append(newSlice, slice[indexWhereToInsert:]...)
	fmt.Println("slice:", slice)	
}

(Note that I've also added the val variable, rather than hardcoding 1 as the value to be inserted.)

Here's a simple shift right example without copy but also includes a loop showing how it's all really pointers.

Playground

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	for _, e := range s {
		// Will always shift 2 as it's been shifted each time
		fmt.Println(e, shiftRight(s, e))
	}
}

func shiftRight(s []int, e int) []int {
	if len(s) > 1 { // No where to shift to if 1 item
		// Go through the slice finding the item to shift
		for i, item := range s {
			if item == e {
				if i == len(s)-1 {
					break // already at the end, can't shift any further
				}
				s[i] = s[i+1]
				s[i+1] = item
				break
			}
		}
	}
	return s
}

If you need the omotto's version with generics:

func insertInt[T any](array []T, value T, index int) []T {
	return append(array[:index], append([]T{value}, array[index:]...)...)
}

func removeInt[T any](array []T, index int) []T {
	return append(array[:index], array[index+1:]...)
}

func moveElement[T any](array []T, srcIndex int, dstIndex int) []T {
	value := array[srcIndex]
	return insertInt(removeInt(array, srcIndex), value, dstIndex)
}