I think it is predictable that the comparisons all return true:

package main

import (
	"fmt"
	"reflect"
)

func main() {
	type box struct{ n *box }
	var b = &box{&box{&box{&box{nil}}}}
	b.n.n.n.n = b.n.n
	
	// all return true
	fmt.Println(reflect.DeepEqual(b, b.n))
	fmt.Println(reflect.DeepEqual(b, b.n.n))
	fmt.Println(reflect.DeepEqual(b.n, b.n.n.n))
	fmt.Println(reflect.DeepEqual(b.n.n, b.n.n.n.n))
}

But, in the following example, the two false results are not expected:

package main

import (
	"fmt"
	"reflect"
)

func main() {
	type P *P
	var p P
	p = &p
	
	fmt.Println(p, &p, *p) // three same addresses
	fmt.Println (p == &p)                  // true
	fmt.Println(reflect.DeepEqual(p, &p))  // false
	fmt.Println (p == *p)                  // true
	fmt.Println(reflect.DeepEqual(p, *p))  // true
	fmt.Println (&p == *p)                 // true
	fmt.Println(reflect.DeepEqual(&p, *p)) // false
	
}

@go101:

I think it is predictable that the comparisons all return true…

For the cases where we are comparing b(.n)^i and b(.n)^i(.n)^(2j) (for i and j being non-negative integers) I agree that it is quite predictable from the docs that the comparison will return true. But for the cases where we compare b(.n)^i and b(.n)^i(.n)(2j+1) I can see no no reason to believe, based on the documentation, that DeepEqual will return true (or at all).

But, what is unexpected is the b.n != b.n.n.n…

That's just because Println is not printing what you think it is. Try this:

	type box struct{ n *box }
	var b = &box{&box{&box{&box{nil}}}}
	b.n.n.n.n = b.n.n

	fmt.Printf("%p %p\n", b.n, b.n.n.n) // not the same addresses
	fmt.Println(b.n == b.n.n.n)         // false, unsurprisingly

And, in the following example, the two false results are also not expected…

They are, if you look at the types:

	type P *P
	var p P
	p = &p

	fmt.Printf("%p (%[1]T) %p (%[2]T) %p (%[3]T)\n", p, &p, *p) // three same addresses

I will admit to being a little surprised to realise that P and *P are not the same type, but upon reflection (no pun intended) that is consistent with the usual behaviour: if we say type ptrInt *int we create a new type that is distinct from its underlying type.

One more confused is the results printed by fmt.Println and println are different:

package main

import (
	"fmt"
)

func main() {
	type box struct{ n *box }
	var b = &box{&box{&box{&box{nil}}}}
	b.n.n.n.n = b.n.n
	
	fmt.Println(b.n, b.n.n, b.n.n.n) 
	println(b.n, b.n.n, b.n.n.n)
	// output:
	// &{0xc42000c030} &{0xc42000c038} &{0xc42000c030}
	// 0xc42000c028 0xc42000c030 0xc42000c038
}

@cpcallen,
[edit]:
Ah, I didn't notice your last comment.
Just found the outputs in this example are correct.

Yes, the types of p and &p are different, but their underlying types are the same,
that's why compiler allows comparing them.
And their values in memory are the same, so I think they should be equal.

Yes, the types of p and &p are different, but their underlying types are the same,
that's why compiler allows comparing them.
And their values in memory are the same, so I think they should be equal.

The documentation for DeepEqual is very clear on this point: "Values of distinct types are never deeply equal." You might prefer the function did something different, but here the behaviour is exactly as documented, so your wish is not relevant to this issue.

Didn't read the DeepEqual docs carefully.
Thanks for the info. No confusions now.

Change https://golang.org/cl/52931 mentions this issue: reflect: document how DeepEqual handles cycles