Go Reflection

import "reflect"

var x float64 = 3.14

t := reflect.TypeOf(x)
fmt.Println(t.Name())   // float64
fmt.Println(t.Kind())   // float64  (same for primitives)

v := reflect.ValueOf(x)
fmt.Println(v.Type())   // float64
fmt.Println(v.Kind())   // float64
fmt.Println(v.Float())  // 3.14  (panics if not float kind)

// Getting the concrete value back out
var result float64 = v.Interface().(float64)

type Person struct {
    Name string
    Age  int
    Email string
}

p := Person{"Alice", 30, "alice@example.com"}
t := reflect.TypeOf(p)
v := reflect.ValueOf(p)

for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)           // reflect.StructField
    value := v.Field(i)           // reflect.Value
    fmt.Printf("%s = %v\n", field.Name, value.Interface())
}
// Name = Alice
// Age  = 30
// Email = alice@example.com

type User struct {
    Name  string `json:"name"             validate:"required,min=2"`
    Email string `json:"email,omitempty"   validate:"required,email"`
    age   int    `json:"-"`               // unexported, json ignores it
}

t := reflect.TypeOf(User{})
f, _ := t.FieldByName("Email")

tag := f.Tag                        // reflect.StructTag
tag.Get("json")                     // "email,omitempty"
tag.Get("validate")                 // "required,email"

// Lookup returns (value, ok) — prefer over Get to distinguish
// missing tag from empty tag value
val, ok := tag.Lookup("json")      // "email,omitempty", true
_, ok  = tag.Lookup("xml")         // "", false

// Encode a struct to map[string]any using json tags as keys
func structToMap(v any) map[string]any {
    out := make(map[string]any)
    rv := reflect.ValueOf(v)
    rt := rv.Type()

    for i := 0; i < rt.NumField(); i++ {
        f := rt.Field(i)
        if !f.IsExported() {
            continue
        }
        key := f.Name
        if tag, ok := f.Tag.Lookup("json"); ok && tag != "-" {
            key = strings.Split(tag, ",")[0]
        }
        out[key] = rv.Field(i).Interface()
    }
    return out
}

type Config struct {
    Timeout int
    Debug   bool
}

cfg := &Config{}

// Must pass pointer and call Elem() to get addressable value
rv := reflect.ValueOf(cfg).Elem()

rv.FieldByName("Timeout").SetInt(30)
rv.FieldByName("Debug").SetBool(true)

fmt.Println(*cfg)  // {30 true}

// Check first to avoid panics on unexported or read-only fields
f := rv.FieldByName("Timeout")
if f.CanSet() {
    f.SetInt(60)
}

func Add(a, b int) int { return a + b }

ft := reflect.TypeOf(Add)
fmt.Println(ft.NumIn(), ft.NumOut())  // 2  1
fmt.Println(ft.In(0))               // int
fmt.Println(ft.Out(0))              // int

fv := reflect.ValueOf(Add)
args := []reflect.Value{
    reflect.ValueOf(3),
    reflect.ValueOf(4),
}
results := fv.Call(args)
fmt.Println(results[0].Int())  // 7

type Greeter struct{ Name string }

func (g Greeter) Hello() string {
    return "Hello, " + g.Name
}

g := Greeter{Name: "Alice"}
v := reflect.ValueOf(g)

m := v.MethodByName("Hello")
if !m.IsValid() {
    fmt.Println("method not found")
    return
}

result := m.Call(nil)
fmt.Println(result[0].String())  // Hello, Alice

// 1. Calling a type-specific extractor on the wrong kind
v := reflect.ValueOf("hello")
v.Int()  // panic: call of reflect.Value.Int on string Value

// 2. Setting a non-addressable value
v = reflect.ValueOf(42)   // not addressable (copy)
v.SetInt(99)             // panic: reflect: reflect.Value.SetInt using value obtained using unexported field

// 3. Calling Interface() on unexported struct field
type S struct{ secret int }
reflect.ValueOf(S{1}).Field(0).Interface()  // panic

// 4. Nil pointer dereference
var p *int
reflect.ValueOf(p).Elem()  // panic: reflect: call of reflect.Value.Elem on zero Value

// ✓ USE reflection for:
//   • Serialization / deserialization libraries (encoding/json, yaml)
//   • ORM / query builders (field → column mapping)
//   • Dependency injection frameworks
//   • Generic testing utilities (DeepEqual, diff)
//   • Reading struct tags to drive behaviour

// ✗ AVOID reflection when:
//   • You could use generics (Go 1.18+) instead
//   • You could use an interface with a defined method set
//   • Performance is critical (reflection is ~10-100x slower)
//   • You control all the types involved

// Rule of thumb: if the caller controls the concrete type,
// use generics. If the library doesn't know the type at
// compile time, use reflection.