Go Type Introspection Challenge: Dynamic Field Access

Type introspection, the ability to examine the structure of a type at runtime, is a powerful tool for building flexible and dynamic applications. This challenge asks you to implement a function that can dynamically access fields of a struct based on a provided string key, mimicking a simplified version of reflection. This is useful for scenarios like generic data processing, serialization/deserialization, and building dynamic configuration systems.

Problem Description

You are tasked with creating a Go function GetFieldValue that takes a struct and a field name (string) as input and returns the value of that field. The function should handle the following:

• Input:
  • interface{}: Represents the struct whose fields you need to access. This allows the function to work with any struct type.
  • string: The name of the field to retrieve.
• Output:
  • interface{}: The value of the specified field. Returns nil if the field is not found or if the input is not a struct.
• Error Handling:
  • If the input is not a struct, return nil.
  • If the field does not exist in the struct, return nil.
• Type Safety: The function should not perform any type assertions or conversions. It should return the raw value as it exists in the struct.
• Panic Prevention: The function must not panic under any circumstances. Handle errors gracefully.

Examples

Example 1:

Input:
struct Example {
    Name string
    Age  int
}

example := Example{Name: "Alice", Age: 30}
fieldName := "Name"

Output:
"Alice"
Explanation: The function retrieves the value of the "Name" field from the Example struct.

Example 2:

Input:
struct Example {
    Name string
    Age  int
}

example := Example{Name: "Bob", Age: 25}
fieldName := "Age"

Output:
25
Explanation: The function retrieves the value of the "Age" field from the Example struct.

Example 3:

Input:
struct Example {
    Name string
    Age  int
}

example := Example{Name: "Charlie", Age: 40}
fieldName := "Address"

Output:
nil
Explanation: The "Address" field does not exist in the Example struct, so the function returns nil.

Example 4:

Input:
123 // Not a struct
fieldName := "AnyField"

Output:
nil
Explanation: The input is not a struct, so the function returns nil.

Constraints

• The input struct can contain fields of any valid Go type.
• The field name is a string and is case-sensitive.
• The function must be performant enough to handle reasonably sized structs (up to 100 fields). While optimization is not the primary goal, avoid excessively inefficient approaches.
• The function must be robust and handle all edge cases described above without panicking.

Notes

• You will need to use the reflect package to achieve type introspection.
• Consider using reflect.ValueOf and reflect.FieldByName to access the struct and its fields.
• Remember to handle potential errors gracefully to prevent panics.
• The goal is to demonstrate understanding of reflection and how to safely access struct fields dynamically. Focus on correctness and robustness over extreme optimization. Avoid unnecessary complexity.