Why does accessing a nil pointer in Go cause an Error in Inorder traversal

I have written inorder traversal in python which works fine.

def inOrderTraverse(tree, array):
    if tree is None:
		return None
	inOrderTraverse(tree.left,array)
	array.append(tree.value)
	inOrderTraverse(tree.right,array)
	return array

However when I try to apply the same logic with GOlang, it does not work.

type BST struct {
	Value int

	Left  *BST
	Right *BST
}

func (tree *BST) InOrderTraverse(array []int) []int {
	if tree == nil {
		return nil
	}
	(tree.Left).InOrderTraverse(array)
	array = append(array,tree.Value)
	(tree.Right).InOrderTraverse(array)
	return array
}

In order to fix this I write if statements to prevent the functions from being called if tree.Left is nil. However I am still confused why my original code does not work.

func (tree *BST) InOrderTraverse(array []int) []int {
	if tree.Left != nil {
		array = tree.Left.InOrderTraverse(array)
	}
	array = append(array,tree.Value)
	if tree.Right != nil {
		array = tree.Right.InOrderTraverse(array)
	}
	return array
}

To summarize, I am trying to write inorder traversal in Go using the same reasoning from python and it is not working. I figured out how to get it to work(the third code block), however I still do not understand why the second code block does not work. It seems like calling the function on the Nil pointer causes an error

A couple of things:

In your 2nd block of code, the reason it does not work is because the result is discarded:

 // (tree.Left).InOrderTraverse(array) // the return result is ignored
 array = (tree.Left).InOrderTraverse(array) // capture it like so

Python uses pass by-reference; Go passes by value. As such it can get tricky especially when modifying things like slices in Go.

Since you're already returning the results of the traversal, passing in the array is actually redundant.

Pulling this all together to fix both left & right traversal - and using a return variable result:

func (tree *BST) InOrderTraverse() (result []int) {
    if tree == nil {
        return // implicitly returns empty `result`
    }

    result = append(result, (tree.Left).InOrderTraverse()...)
    result = append(result, tree.Value)
    result = append(result, (tree.Right).InOrderTraverse()...)

    return // implicitly returns `result`
}

Working example: https://play.golang.org/p/AUvgZTABiU9

EDIT

A Go "pass by reference" implementation - where the results slice is passed between calls - looks very similar to your python implementation:

func (tree *BST) InOrderTraverse(result *[]int) {
	if tree == nil {
		return
	}

	(tree.Left).InOrderTraverse(result)

	*result = append(*result, tree.Value)

	(tree.Right).InOrderTraverse(result)
}

https://play.golang.org/p/Pp9-4-y-lmE

Note: *[]int (i.e. a pointer to []int) is needed here, as the slice capacity will change during the recursion. A slice is really just a header with a backing array - so while a function can change a slice's elements - even when copied by value - it cannot make the slice shrink or grow (as is the case here). Passing a pointer allows the slice to be reassigned to a potentially larger backing array.