Go: pop from a map

Is there an existing function where we can pop a (key,value) pair from a map in GO? I use the word pop instead of remove because a pop would re-arrange the elements after the index where the (key,value) was removed.

As an example the following code:

package main

import "fmt"

func main() {
	mapp := make(map[int]int)
	fmt.Println("before removal:")

	for i := 1; i < 7; i++ {
		mapp[i] = i
	}
	fmt.Println(mapp)
	delete(mapp, 2)
    fmt.Println("\nafter the removal:")
	for i := 1; i < 7; i++ {
		fmt.Println(i, mapp[i])
	}

}

Produces the following output:

before removal:
map[1:1 2:2 3:3 4:4 5:5 6:6]

after the removal:
1 1
2 0
3 3
4 4
5 5
6 6

We notice that index location 2 is empty. I would like the output to be the following:

before removal:
map[1:1 2:2 3:3 4:4 5:5 6:6]

after the removal:
1 1
2 3
3 4
4 5
5 6

Is this functionality already in Go or would I have to implement it?

I think that you are misunderstanding what a map is and how it works. You should not see it as an "array with gaps", but as a classic hash table.

And to answer your question, when you use delete(), the value is deleted from the map, the problem is how you iterate over the "values" of the map.

To help you understand:

mapp := make(map[int]int)
fmt.Println(2, mapp[2])

will print

2 0

Why ? Simply because when the requested key doesn't exist, we get the value type's zero value. In this case the value type is int, so the zero value is 0.

So, you want to see if a key exists in the map before printing it and you have to use two-value assignment, like that:

for i := 1; i < 7; i++ {
    if value, exists := mapp[i]; exists {
        fmt.Println(i, value)
    }
}

and it will print

1 1
3 3
4 4
5 5
6 6

Not really what you want, but the closer you can get directly with maps.
You can have a look at this blog post for more information and examples.

If you really want to have an array where you can remove values, see Verran's answer and use slices instead.

From the Go documentation:

When iterating over a map with a range loop, the iteration order is not specified and is not guaranteed to be the same from one iteration to the next.

From this, it follows that there would be no way to automatically move a value up one position to fill a gap, since the key can be in a different iteration position each time you look at the values and theres no guarantee that the value mapped to 2 will slide up to 1.

If you want to do something like this, you will have to manually shift everything down one key value, something like:

for key := 2; key < len(map)-1; key++ {
    map[key] = map[key+1]
}

Alternatively, you could use slices and if you know the index you need to "pop", create a new slice that omits the value:

value := slice[2]
slice = copy(slice[:2], slice[2+1:])