The Go Interface Mystery Every Senior Developer Gets Wrong

Interface Structure:
┌─────────────┐
│    _type    │ ──> Points to *User type metadata
├─────────────┤
│    data     │ ──> Points to nil (no actual User instance)
└─────────────┘

// Type 1: Completely nil interface (both type and data are nil)
var completelyNil UserIFace = nil
fmt.Printf("completelyNil == nil: %v\n", completelyNil == nil) // true

// Type 2: Interface with nil value but concrete type info
var nilUser *User = nil
var interfaceWithNilUser UserIFace = nilUser
fmt.Printf("interfaceWithNilUser == nil: %v\n", interfaceWithNilUser == nil) // false

func processUser(u UserIFace) {
	if u == nil {
		fmt.Println("No user interface provided")
		return
	}
	
	// We can still call methods on nil receivers if they're designed for it!
	// This is only possible because Go knows the type
	if reflect.ValueOf(u).IsNil() {
		fmt.Println("User value is nil, but we know it's a *User")
		// Could call methods that handle nil receivers
	} else {
		fmt.Printf("User name: %s\n", u.GetName())
	}
}

func getUserFromCache(id string) UserIFace {
	if id == "" {
		return nil // No user interface at all
	}
	
	user := lookupInCache(id)
	if user == nil {
		return (*User)(nil) // We know it should be a User, but it's nil
	}
	
	return user
}

func handleCacheResult(u UserIFace) {
	if u == nil {
		fmt.Println("Invalid request - no user type expected")
	} else if reflect.ValueOf(u).IsNil() {
		fmt.Println("Valid request - user not found in cache")
	} else {
		fmt.Printf("Found user: %s\n", u.GetName())
	}
}

package main

import (
	"fmt"
	"reflect"
)

type UserIFace interface {
	GetName() string
}

type AdminIFace interface {
	GetPermissions() []string
}

type User struct {
	Name string
}

func (u *User) GetName() string {
	if u == nil {
		return "Unknown User"
	}
	return u.Name
}

type Admin struct {
	Name        string
	Permissions []string
}

func (a *Admin) GetName() string {
	if a == nil {
		return "Unknown Admin"  
	}
	return a.Name
}

func (a *Admin) GetPermissions() []string {
	if a == nil {
		return []string{}
	}
	return a.Permissions
}

// Problematic factory function
func CreateUserByRole(role string) UserIFace {
	switch role {
	case "admin":
		var admin *Admin = nil // Simulating admin not found
		return admin           // Returns interface containing (*Admin)(nil)
	case "user":
		var user *User = nil   // Simulating user not found  
		return user            // Returns interface containing (*User)(nil)
	default:
		return nil            // Returns really nil interface
	}
}

func main() {
	fmt.Println("=== Factory Pattern Demonstration ===")
	
	roles := []string{"admin", "user", "guest"}
	
	for _, role := range roles {
		userInterface := CreateUserByRole(role)
		
		fmt.Printf("\nRole: %s\n", role)
		fmt.Printf("userInterface == nil: %v\n", userInterface == nil)
		
		if userInterface != nil {
			fmt.Printf("Type: %v\n", reflect.TypeOf(userInterface))
			fmt.Printf("Value is nil: %v\n", reflect.ValueOf(userInterface).IsNil())
			
			// This will work even with nil values due to nil-safe methods! 
            // cool sidenote, this is also why you can call methods on nil receivers if they're designed for it,
            // protobuf uses this to great effect in the generated code for getters and setters.
			fmt.Printf("GetName(): %s\n", userInterface.GetName())
		}
	}
	
	// The real problem: downstream code expects nil checks to work
	fmt.Println("\n=== The Problem ===")
	adminUser := CreateUserByRole("admin")
	
	// Programmer expects this to work:
	if adminUser == nil {
		fmt.Println("No admin user - using default permissions")
	} else {
		fmt.Println("Admin user found - loading admin dashboard")
		// This code will execute even though admin is actually nil!
		// could cause runtime panics if methods aren't nil-safe
	}
}

swapnilnair@Swapnil-Nairs-MacBook-Pro sandbox % go run main.go
=== Factory Pattern Demonstration ===

Role: admin
userInterface == nil: false
Type: *main.Admin
Value is nil: true
GetName(): Unknown Admin

Role: user
userInterface == nil: false
Type: *main.User
Value is nil: true
GetName(): Unknown User

Role: guest
userInterface == nil: true

=== The Problem ===
Admin user found - doing admin things muhahahaha !! 

type CustomError struct {
	Message string
	Code    int
}

func (e *CustomError) Error() string {
	if e == nil {
		return "unknown error"
	}
	return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func doSomething() error {
	var err *CustomError = nil
	
	// Some logic that might set err
	if someCondition {
		return err // Returns interface containing (*CustomError)(nil)
	}
	
	return nil // Returns truly nil interface
}

func main() {
	if err := doSomething(); err != nil {
		fmt.Printf("Error occurred: %v\n", err) // This will always execute!
	}
}

func CreateUserByRole(role string) UserIFace {
	switch role {
	case "admin":
		admin := getAdminFromDB() // Returns *Admin or nil
		if admin == nil {
			return nil // Return truly nil interface
		}
		return admin
	case "user":
		user := getUserFromDB() // Returns *User or nil  
		if user == nil {
			return nil // Return truly nil interface
		}
		return user
	default:
		return nil
	}
}

func (u *User) GetName() string {
	if u == nil {
		return "Guest User" // Graceful handling of nil receiver
	}
	return u.Name
}

func (u *User) IsValid() bool {
	return u != nil && u.Name != ""
}

func ProcessUser(userInterface UserIFace) {
	if userInterface == nil {
		fmt.Println("No user interface provided")
		return
	}
	
	// Type assert and check for nil
	if user, ok := userInterface.(*User); ok {
		if user == nil {
			fmt.Println("User interface contains nil *User")
			return
		}
		fmt.Printf("Processing user: %s\n", user.Name)
	} else if admin, ok := userInterface.(*Admin); ok {
		if admin == nil {
			fmt.Println("User interface contains nil *Admin")
			return  
		}
		fmt.Printf("Processing admin: %s\n", admin.Name)
	}
}