Explain the nil interface trap in Go. Why does a typed nil fail the '!= nil' check?

This is one of the most frequently asked Go interview questions. The trap: an interface value is only nil when both its type pointer and its data pointer are zero. If you assign a nil pointer of a concrete type to an interface variable, the type pointer becomes non-zero — so the interface is not nil, even though the data it holds is nil.

type MyError struct{ code int }
func (e *MyError) Error() string { return fmt.Sprintf("error %d", e.code) }

// BUGGY function — looks like it returns nil on the happy path
func riskyOperation(fail bool) error {
    var err *MyError   // nil *MyError
    if fail {
        err = &MyError{code: 42}
    }
    return err  // WRONG: assigns typed nil to error interface
                // interface layout: {type=*MyError, data=nil}
}

e := riskyOperation(false)
if e != nil {  // TRUE — interface is non-nil even though data is nil!
    fmt.Println("BUG: this branch runs unexpectedly:", e)
}

// Correct fix: return untyped nil
func safeOperation(fail bool) error {
    if fail {
        return &MyError{code: 42}
    }
    return nil  // untyped nil → both words zeroed → truly nil interface
}

// Another correct approach: keep return type concrete
func concreteReturn(fail bool) *MyError {
    if fail { return &MyError{code: 42} }
    return nil  // nil pointer returned as concrete type, not interface
}

// Debug a suspicious interface with reflect
e2 := riskyOperation(false)
fmt.Println(e2 == nil)                           // false
fmt.Println(reflect.ValueOf(e2).IsNil())         // true — data IS nil
fmt.Printf("%T\n", e2)                           // *main.MyError

Root cause: the language spec defines interface equality as requiring both words to be zero. Assigning any concrete type (even a nil pointer of that type) populates the type word. The only way to produce a nil interface is to assign the bare nil literal or another nil interface variable.

Rule: when your function returns an interface type (like error), always return the bare nil keyword on the success path. Never return a typed nil pointer (var e *MyError; return e).

Invest now in Acorns!!! 🚀
Join Acorns and get your $5 bonus!

Acorns is a micro-investing app that automatically invests your "spare change" from daily purchases into diversified, expert-built portfolios of ETFs. It is designed for beginners, allowing you to start investing with as little as $5. The service automates saving and investing. Disclosure: I may receive a referral bonus.

Invest now!!! Get Free equity stock (US, UK only)!

Use Robinhood app to invest in stocks. It is safe and secure. Use the Referral link to claim your free stock when you sign up!.

The Robinhood app makes it easy to trade stocks, crypto and more.

Webull! Receive free stock by signing up using the link: Webull signup.