Dynamic Type Inspection in Go

Runtime type information (RTI) allows a program to inspect the type of a variable at runtime, enabling flexible and dynamic behavior. This is particularly useful when dealing with interfaces or when you need to handle different data types in a generic way without resorting to type assertions everywhere. This challenge asks you to implement a system that can dynamically determine the type of a Go value and perform actions based on that type.

Problem Description

You are tasked with creating a function InspectAndAct that takes a generic interface{} as input. This function should:

1. Determine the underlying type: Use the reflect package to determine the concrete type of the input value.
2. Perform type-specific actions: Based on the type, perform a specific action:
   • int: Print "It's an integer! Value: " followed by the integer value.
   • string: Print "It's a string! Value: " followed by the string value.
   • float64: Print "It's a float64! Value: " followed by the float64 value.
   • []int: Print "It's a slice of integers! Length: " followed by the length of the slice.
   • map[string]int: Print "It's a map of string to integer! Length: " followed by the length of the map.
   • For any other type: Print "Unknown type!"
3. Handle nil values: If the input value is nil, print "Value is nil."

Examples

Example 1:

Input: 10
Output: It's an integer! Value: 10
Explanation: The input is an integer, so the integer-specific action is performed.

Example 2:

Input: "hello"
Output: It's a string! Value: hello
Explanation: The input is a string, so the string-specific action is performed.

Example 3:

Input: 3.14
Output: It's a float64! Value: 3.14
Explanation: The input is a float64, so the float64-specific action is performed.

Example 4:

Input: []int{1, 2, 3}
Output: It's a slice of integers! Length: 3
Explanation: The input is a slice of integers, so the slice-specific action is performed.

Example 5:

Input: map[string]int{"a": 1, "b": 2}
Output: It's a map of string to integer! Length: 2
Explanation: The input is a map of string to integer, so the map-specific action is performed.

Example 6:

Input: nil
Output: Value is nil.
Explanation: The input is nil, so the nil-handling action is performed.

Constraints

• The input will always be of type interface{}.
• The function must use the reflect package to determine the type.
• The function must handle the specified types (int, string, float64, []int, map[string]int) and a default "Unknown type!" case.
• The function must handle nil values gracefully.
• The code should be readable and well-commented.

Notes

• The reflect package provides powerful tools for introspection. Familiarize yourself with functions like reflect.TypeOf() and methods on reflect.Value to access type and value information.
• Consider using a switch statement or a type switch to handle the different types efficiently.
• Remember that accessing values using reflection can be slightly slower than direct access, but the flexibility it provides is often worth the trade-off.
• Pay close attention to how you extract the underlying value from the reflect.Value object. Use appropriate methods like Interface() or Int(), String(), etc., depending on the type.