这是Golang惯用的代码吗？ 持久树

I am learning GO and I am trying to implement something not too trivial, a persistent balanced tree and I am wonder if the code I wrote is idiomatic or not.

Here is the incomplete code:

package main

import (
       "fmt"
       "errors"
)

type Node struct{
     value int
     left * Node
     right * Node
}

func TraverseTree(root Node) {
     if root.value != 0 {
        TraverseTree(*root.left)
        fmt.Println(root.value)
    TraverseTree(*root.right)}
     return
}

func MakeNode(value int) (Node) {
     node := Node{value: value,
                 right: &Node{},
         left:  &Node{}}
     return node
}

func AddNode(root Node, value int) (newNode Node, error error){
     alreadyPresentError := errors.New("Element already present")
     if root.value == 0 {
        fmt.Println("Creating new Node of value: ", value)
        newNode = MakeNode(value)
    error = nil
     } else if root.value == value {
        newNode = root
        error = alreadyPresentError
     }else if value > root.value{ //going right
        fmt.Println("Going Right")
        nodeLeft, err := AddNode(*root.right, value)
    if err != nil {
        newNode = root
        err = alreadyPresentError
    }else{
            newNode = Node{value: root.value, 
                       left:  root.left, 
                   right: &nodeLeft}
        error = nil}
     }else if value < root.value{ //going left
        fmt.Println("Going left")
        nodeRight, err := AddNode(*root.left, value)
    if err != nil {
        newNode = root
        err = alreadyPresentError
    }else{
            newNode = Node{value: root.value, 
                   left:  &nodeRight, 
               right: root.right}
        error = nil}}
     return
}

What doesn't really convince me is how I manage the error, but probably there are some other error.

There are a couple of things that should be dealt with:

• Always format your code with go fmt
• Use switch instead of if-else chains

The rest is more a matter of taste. You could probably make the code more clear by not using named return values, but that is my oppinion. Below is my suggestion:

// Moved it up here to reuse a single instance of the error
var alreadyPresentError = errors.New("Element already present")

func AddNode(root Node, value int) (Node, error) {
    switch {
    case root.value == 0:
        fmt.Println("Creating new Node of value: ", value)
        return MakeNode(value), nil
    case root.value == value:
        return root, alreadyPresentError
    case value > root.value:
        //going right
        fmt.Println("Going Right")
        nodeLeft, err := AddNode(*root.right, value)
        if err != nil {
            return root, alreadyPresentError
        }
        return Node{value: root.value,
            left:  root.left,
            right: &nodeLeft}, nil    
    case value < root.value: //going left
        fmt.Println("Going left")
        nodeRight, err := AddNode(*root.left, value)
        if err != nil {
            return root, alreadyPresentError
        }
        return Node{value: root.value,
            left:  &nodeRight,
            right: root.right}, nil    
    }
    // Dummy return. If you don't like dummies, delete the case root.value == value case
    return root, alreadyPresentError
}