When should you use reflection instead of interfaces for type-agnostic code in Go?

// Interface approach — compile-time safety
type Serialiser interface{ Serialise() []byte }

func saveToFile(s Serialiser, path string) error {
    return os.WriteFile(path, s.Serialise(), 0644)
}

// Reflection approach — needed when structure is unknown at compile time
// (like JSON encoding)
func toMap(v any) map[string]any {
    result := make(map[string]any)
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr { val = val.Elem() }
    if val.Kind() != reflect.Struct { return nil }
    typ := val.Type()
    for i := 0; i < val.NumField(); i++ {
        field := typ.Field(i)
        if !field.IsExported() { continue }
        key := field.Tag.Get("json")
        if key == "" { key = field.Name }
        result[key] = val.Field(i).Interface()
    }
    return result
}

// Generics (Go 1.18+) — preferred over reflection for type-agnostic algorithms
func Map[T, U any](slice []T, f func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice { result[i] = f(v) }
    return result
}
// No reflection, compile-time safe, fast