Reference values not being updated

I am new to the Golang world & trying to implement a BST in Golang. But while inserting/updating pointers values are not getting updated/inserted. For example in the following code the output is:

3
[]

my code:

package main

import "fmt"

var inOrderTrace []int = []int{}

type node struct {
	value      int
	leftChild  *node
	rightChild *node
}

type tree struct {
	root *node
	len  int
}

func (myTree tree) inOrderTraverse(node *node) {
	if node == nil {
		return
	}
	myTree.inOrderTraverse(node.leftChild)
	inOrderTrace = append(inOrderTrace, node.value)
	myTree.inOrderTraverse(node.rightChild)
}

func (myTree *tree) insertNode(nodeToManipulate *node, toInsert int) {
	if nodeToManipulate == nil {
		nodeToManipulate = &node{toInsert, nil, nil}
		myTree.len++
		return
	}
	if nodeToManipulate.value > toInsert {
		myTree.insertNode(nodeToManipulate.leftChild, toInsert)
	} else {
		myTree.insertNode(nodeToManipulate.rightChild, toInsert)
	}
}

func main() {
	myTree := &tree{nil, 0}
	var elements []int = []int{1, 0, 2}
	for _, element := range elements {
		myTree.insertNode(myTree.root, element)
	}
	myTree.inOrderTraverse(myTree.root)
	fmt.Println(myTree.len)
	fmt.Println(inOrderTrace)
}

I am expecting the inserted values to be printed.Thanks.

insertNode() has a parameter of pointer type (nodeToManipulate *node). Inside insertNode():

nodeToManipulate = &node{toInsert, nil, nil}

This line will just assign a pointer to the parameter, a local variable. Calling this method from main(), and passing myTree.root, the myTree.root will never be modified, as written above, only the function parameter (which is a copy, a local variable). This means your tree never gets built, the root of tree never gets modified.

To modify something, you have to pass a pointer to it, and modify the pointed value.

For example:

func (myTree *tree) insertNode(pnodeToManipulate **node, toInsert int) {
	if *pnodeToManipulate == nil {
		*pnodeToManipulate = &node{toInsert, nil, nil}
		myTree.len++
		return
	}
	nodeToManipulate := *pnodeToManipulate
	if nodeToManipulate.value > toInsert {
		myTree.insertNode(&nodeToManipulate.leftChild, toInsert)
	} else {
		myTree.insertNode(&nodeToManipulate.rightChild, toInsert)
	}
}

func main() {
	myTree := &tree{nil, 0}
	var elements []int = []int{1, 0, 2}
	for _, element := range elements {
		myTree.insertNode(&myTree.root, element)
	}
	myTree.inOrderTraverse(myTree.root)
	fmt.Println(myTree.len)
	fmt.Println(inOrderTrace)
}

With this change output will be (try it on the Go Playground):

3
[0 1 2]

If you don't like double pointers (**), another option is to return the new value and assign it at the caller.

See related / possible duplicates:

https://stackoverflow.com/questions/35421495/can-the-pointer-in-a-struct-pointer-method-be-reassigned-to-another-instance/35426997#35426997

https://stackoverflow.com/questions/61761945/how-to-modify-the-value-of-a-simple-type-through-pointer-receiver-method-in-go/61762145#61762145

https://stackoverflow.com/questions/45288751/what-use-case-does-pointers-to-pointer-eg-int-have/45297016#45297016