Nothing is Passed by Reference

So we have the practical notion of passing by value versus passing by reference. There are others, too. But they are pretty much dead.

For many languages, we probably have a practical model in mind. Lists, maps and objects are passed by reference, while primitives and strings are passed by value.

If you think about it everything is still passed by value. If you are passing a list into a function, what you do really is you are passing the pointer/address/descriptor (whatever term you prefer in this case) of that list as value into the function. It just happens that we could use that pointer value to find and manipulate the list.

Now, for some languages you could also choose to pass a pointer into the function. That is by value, too. We are passing the value of the pointer. So, my mental model is that the pointer value of a map is the address of the address of the map descriptor, and the map descriptor knows how to manipulate the map.

There is probably nothing surprising in the above mental model though. For example, see this following snippet in Golang. Future me, make sure you know why the mental model makes sense.

package main

import "fmt"

func changeMap(mm map[int]int) {
	mm[0] = 1
	mm = make(map[int]int)
	mm[0] = 2
}

func changeMapAlt(mmp *map[int]int) {
	(*mmp) = make(map[int]int)
	(*mmp)[0] = 3
}

func main() {
	mm := make(map[int]int)
	fmt.Printf("%v %p %[1]p \n", mm, &mm) //map[] 0xc000112018 0xc00010e0c0
	changeMap(mm)
	fmt.Printf("%v %p %[1]p \n", mm, &mm) //map[0:1] 0xc000112018 0xc00010e0c0
	changeMapAlt(&mm)
	fmt.Printf("%v %p %[1]p \n", mm, &mm) //map[0:3] 0xc000112018 0xc00010e0c0
}

The first address never changes because that is the address where mm descriptor is stored. The second address changes because changeMapAlt swapped out the descriptor.