modify slice in function

I noticed today that the address of a slice does not change when I pass slice by value, so in that case I would expect the slice in main() to have the same backing array as the slice inside the function.

BUT that cannot be, because the contents of the slice are different in the function vs in main after function return.

Here is sample code to demonstrate (golang 1.16), where append() DOES NOT CREATE a new object (because I set the capacity to avoid that):

package main

import (
	"fmt"
)

// must use pointer since modifying the slice
func modSlice(mySlice *[]string) {
	*mySlice = append(*mySlice, "abc")
	fmt.Printf("In modSlice(): %p %v\n", *mySlice, len(*mySlice))
}

// this ones shows same address for mySlice as in main!
func modSliceFail(mySlice []string) {
	mySlice = append(mySlice, "ABC")
	fmt.Printf("In modSliceFail(): %p %v\n", mySlice, len(mySlice))
}

func main() {
	mySlice := make([]string, 0, 100)
	fmt.Printf("In main() before: %p %v\n\n", mySlice, len(mySlice))

	modSlice(&mySlice)
	fmt.Printf("In main() after modSlice(pointer to slice): %p %v\n\n", mySlice, len(mySlice))

	modSliceFail(mySlice)
	fmt.Printf("In main() after modSliceFail(): %p %v\n\n", mySlice, len(mySlice))
}

which produces the following output:

In main() before: 0xc000115500 0

In modSlice(): 0xc000115500 1
In main() after modSlice(pointer to slice): 0xc000115500 1

In modSliceFail(): 0xc000115500 2
In main() after modSliceFail(): 0xc000115500 1

Notice how the pointer to the slice is the same throughout. How is this possible, if the slice is copied by value in the case of modSliceFail()?

Edit:
The 2 answers so far do not answer my question. I understand how append works and that if the capacity is insufficient, a new object will be returned. That's why I set the capacity in the example code above, so this would not happen. The issue is that pointer inside the fail function is same as in main, both before append (showing the function is using not just the same slice header, but the same slice object) and after append (showing again the object, which is not the case of capacity is 1).

Other answer is great, I just wanted to summarize some of the points on this
topic. If the argument is a slice, you can edit but not append, regardless of
capacity. If the argument is a pointer, you can edit and append. Example:

package main
import "fmt"

func oneTwo(b []byte) {
   b[0] = 1
   b = append(b, 2)
}

func threeFour(b *[]byte) {
   (*b)[0] = 3
   *b = append(*b, 4)
}

func main() {
   b := make([]byte, 1, 9)
   oneTwo(b)
   fmt.Println(b) // [1]
   threeFour(&b)
   fmt.Println(b) // [3 4]
}

If you read carefully my question, it is about pointers I'm expecting to be different but instead output shows them to be the same, whereas we know they should be different. The answers all focus on the typical other question of why pointers can be different after slice append() etc.

The correct answer is that %p on a slice does not print the address of slice, it prints the address of the first element of slice, ie of its backing array (see https://pkg.go.dev/fmt?utm_source=gopls#pkg-overview).

So my sample code was not actually printing what I thought it was. It's admittedly a silly mistake. If I use %p on the address of slice instead of slice itself, everything makes sense.

Here is paired down code that shows this:

package main

import (
	"fmt"
)

func modSliceFail(mySlice []string) {
	fmt.Println("\nIn modSlice():")
	fmt.Printf("%50v: %p    %p\n", "mySlice header address, backend array address", &mySlice, mySlice)
	fmt.Printf("%50v\n", "(header different from main, same backing array)")
}

func main() {
	mySlice := make([]string, 0)
	fmt.Println("INIT:")
	fmt.Printf("%50v: %p    %p\n", "mySlice header address, backend array address", &mySlice, mySlice)

	modSliceFail(mySlice)
}

outputs

INIT:
     mySlice header address, backend array address: 0xc00000c030    0xc000010240

In modSlice():
     mySlice header address, backend array address: 0xc00000c060    0xc000010240
  (header different from main, same backing array)

In my original post, I was printing the address of backing array (2nd column in the below output), not that of slice.

Appending onto a slice may return a new slice if it needs to reallocate a backing array.

This example in the playground:

func printSlice(desc string, s []int) {
	if cap(s) == 0 {
		fmt.Printf("%s:\tempty\n", desc)
		return
	}
	full := s[:cap(s)]
	fmt.Printf("%s:\tlen=%d,\tcap=%d,\tarray=%v @ %p,\tslice=%v\n",
		desc, len(s), cap(s), full, &full[0], s)
}

func main() {
	arr := [10]int{}

	s := arr[:0]
	printSlice("start", s)

	// There is plenty of room for 5 elements
	s = append(s, 1, 1, 1, 1, 1)
	printSlice("first 5", s)

	// and just enough room  for 5 more, so the backing array is reused
	s = append(s, 2, 2, 2, 2, 2)
	printSlice("second 5", s)

	// but an entirely new slice with a different array is returned once it can't fit
	s = append(s, 3, 3, 3, 3, 3)
	printSlice("third 5", s)
}

will print:

start:      len=0,	cap=10,	array=[0 0 0 0 0 0 0 0 0 0]                     @ 0xc0000be000,	slice=[]
first 5:	len=5,	cap=10,	array=[1 1 1 1 1 0 0 0 0 0]                     @ 0xc0000be000,	slice=[1 1 1 1 1]
second 5:	len=10,	cap=10,	array=[1 1 1 1 1 2 2 2 2 2]                     @ 0xc0000be000,	slice=[1 1 1 1 1 2 2 2 2 2]
third 5:	len=15,	cap=20,	array=[1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 0 0 0 0 0] @ 0xc0000c4000,	slice=[1 1 1 1 1 2 2 2 2 2 3 3 3 3 3]

This is why the append builtin returns a slice instead of modifying it in place: in order to get the new slice after it is grown, you have to replace the value that was given to append.

In your code, when you say

    *mySlice = append(*mySlice, "abc")

you are overwriting the slice value, so the caller is able to observe the result of the append. However, when you say

    mySlice = append(mySlice, "ABC")

that is only overwriting a local variable, so the caller can't see the new slice. You will likely want to write something like

func modSliceFailFixed(mySlice []string) []string {
    mySlice = append(mySlice, "ABC")
    return mySlice
}
// call like:
s = modSliceFailFixed(s)

if you need to have a function that might require changing the dimensions of a slice.