How do type assertions work on interface values and when do you use them?

type Animal interface { Sound() string }
type Dog struct{ Name string }
func (d Dog) Sound() string { return "Woof" }

var a Animal = Dog{Name: "Rex"}

// Form 1: single return — panics if a does not hold a Dog
d := a.(Dog)
fmt.Println(d.Name) // Rex

// Form 2: comma-ok — safe, never panics
d2, ok := a.(Dog)
if ok {
    fmt.Println(d2.Name) // Rex
}

// Wrong type — form 2 gracefully handles it
type Cat struct{}
func (Cat) Sound() string { return "Meow" }
_, ok = a.(Cat) // ok = false — a holds Dog, not Cat

// Interface-to-interface assertion — check if concrete type satisfies another interface
type Namer interface{ Name() string }
type NamedDog struct{ name string }
func (n NamedDog) Sound() string { return "Woof" }
func (n NamedDog) Name()  string { return n.name }

var a2 Animal = NamedDog{name: "Buddy"}
if namer, ok := a2.(Namer); ok {
    fmt.Println("name:", namer.Name()) // name: Buddy
}

// Type switch — idiomatic multi-type dispatch
func handleAnimal(a Animal) {
    switch v := a.(type) {
    case Dog:     fmt.Println("Dog:", v.Name)
    case Cat:     fmt.Println("Cat")
    case NamedDog: fmt.Println("NamedDog:", v.name)
    default:      fmt.Printf("Unknown: %T\n", v)
    }
}