What are the edge cases in Go interface value equality that trip up experienced developers?

// Case 1: nil interface vs interface holding nil pointer
var p *int
var i interface{} = p  // i has type *int, data nil
fmt.Println(p == nil)  // true  — p is a nil pointer
fmt.Println(i == nil)  // FALSE — i has a non-nil type word

// Case 2: two different interface types wrapping the same concrete value
type A interface{ Foo() }
type B interface{ Foo() }
type S struct{}
func (S) Foo() {}

var a A = S{}
var b B = S{}
// a == b  // COMPILE ERROR: invalid operation — a and b are different interface types
// But:
fmt.Println(reflect.DeepEqual(a, b)) // true — same concrete type and value

// Case 3: two interface values of the same type
var a1 A = S{}
var a2 A = S{}
fmt.Println(a1 == a2) // true — S{} == S{} (empty struct is comparable)

// Case 4: interface wrapping uncomparable type — RUNTIME PANIC
type WithSlice struct{ s []int }
func (WithSlice) Foo() {}
var a3 A = WithSlice{s: []int{1}}
var a4 A = WithSlice{s: []int{1}}
// fmt.Println(a3 == a4) // PANIC: runtime error: comparing uncomparable type main.WithSlice

// Case 5: comparing interface to its concrete value directly
var s interface{} = "hello"
fmt.Println(s == "hello") // true — right side promoted to interface, then compared