Go Type Introspection Explorer

This challenge is designed to help you understand and utilize Go's powerful reflection capabilities. You will implement a function that can inspect the type and value of any given Go variable, reporting its kind, name, and fields if it's a struct. This is fundamental for building flexible and dynamic Go applications.

Problem Description

Your task is to implement a function, let's call it InspectType, that accepts an interface{} as input. This function should analyze the provided variable and print information about its type and value.

Key Requirements:

1. Identify the Kind: Determine the fundamental kind of the variable (e.g., int, string, struct, slice, map, ptr, etc.).
2. Report Type Name: For named types (like int, string, or custom struct types), report the full name of the type. For anonymous types, report the kind.
3. Inspect Struct Fields: If the variable is a struct, iterate through its fields. For each field, report its name and the string representation of its value.
4. Handle Pointers: If the input is a pointer, dereference it and inspect the underlying value.
5. Handle Slices and Arrays: If the input is a slice or an array, iterate through its elements and print their string representation.
6. Handle Maps: If the input is a map, iterate through its key-value pairs and print their string representation.
7. Handle Basic Types: For basic types like integers, floats, strings, booleans, etc., print their string representation.
8. Output Format: The output should be clearly formatted and easy to read, indicating the kind, type name, and field/element/value details.

Expected Behavior:

The InspectType function should recursively inspect nested structures, slices, maps, and pointers.

Edge Cases to Consider:

• nil values for various types.
• Empty slices, arrays, and maps.
• Structs with unexported fields (you should be able to inspect them).
• Pointers to nil.

Examples

Example 1:

Input:

var num int = 42
InspectType(num)

Output:

Kind: Int
Type Name: int
Value: 42

Explanation: The input is an integer. Its kind is Int, its type name is int, and its value is 42.

Example 2:

Input:

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}
InspectType(p)

Output:

Kind: Struct
Type Name: Person
Fields:
  Name: Alice
  Age: 30

Explanation: The input is a struct of type Person. Its kind is Struct, its type name is Person. It has two fields: Name with value Alice and Age with value 30.

Example 3:

Input:

type Job struct {
    Title    string
    Duration int
}
type Employee struct {
    EmployeeID int
    Personal   Job
    IsActive   bool
    Score      *float64
}
score := 95.5
e := Employee{
    EmployeeID: 101,
    Personal:   Job{Title: "Engineer", Duration: 5},
    IsActive:   true,
    Score:      &score,
}
InspectType(&e) // Passing a pointer to the struct

Output:

Kind: Struct
Type Name: Employee
Fields:
  EmployeeID: 101
  Personal: Kind: Struct
Type Name: Job
Fields:
  Title: Engineer
  Duration: 5
  IsActive: true
  Score: Kind: Ptr
Type Name: *float64
Value: 95.5

Explanation: The input is a pointer to an Employee struct. The InspectType function dereferences the pointer and then recursively inspects the Employee struct and its nested Job struct, as well as the pointer to float64.

Example 4:

Input:

data := []string{"apple", "banana", "cherry"}
InspectType(data)

Output:

Kind: Slice
Type Name: []string
Elements:
  0: apple
  1: banana
  2: cherry

Explanation: The input is a slice of strings. Its kind is Slice, its type name is []string. It has three elements, each printed with its index and value.

Example 5:

Input:

myMap := map[string]int{"one": 1, "two": 2}
InspectType(myMap)

Output:

Kind: Map
Type Name: map[string]int
Entries:
  one: 2
  two: 1

Explanation: The input is a map. Its kind is Map, its type name is map[string]int. It has two key-value entries.

Example 6:

Input:

var nilPtr *int
InspectType(nilPtr)

Output:

Kind: Ptr
Type Name: *int
Value: <nil>

Explanation: The input is a nil pointer. Its kind is Ptr, its type name is *int. Its value is reported as <nil>.

Constraints

• The solution must be written in Go.
• The InspectType function should accept interface{}.
• Avoid using external libraries that directly provide advanced reflection utilities beyond the standard reflect package.
• The function should be able to handle a reasonable depth of nested types and a reasonable number of elements/fields.

Notes

• The reflect package in Go is your primary tool for this challenge. Familiarize yourself with reflect.ValueOf() and reflect.TypeOf().
• Pay attention to the Kind() and Type() methods of reflect.Value and reflect.Type respectively.
• You'll likely need to use Interface() to get the underlying value when needed.
• Consider using recursion to handle nested structures.
• For structs, NumField() and Field(i) will be essential.
• For slices and arrays, Len() and Index(i) will be useful.
• For maps, Len() and MapRange() or MapKeys() and MapIndex() will be necessary.
• The fmt.Sprintf("%v", value) can be used to get a string representation of values.
• Remember to handle the reflect.Ptr kind to dereference pointers.
• The reflect.Invalid kind should also be considered, particularly for nil inputs.