Understanding Go's Empty Interface: The interface{}

In Go, interfaces are a fundamental concept for achieving polymorphism and flexible code design. The empty interface, represented by interface{}, is particularly powerful as it can hold values of any type. This challenge will help you understand how to declare, assign to, and work with values of the empty interface.

Problem Description

Your task is to demonstrate your understanding of Go's empty interface. You will write a program that:

1. Declares a variable of the empty interface type (interface{}).
2. Assigns different types of values (integer, string, boolean, float, and a struct) to this variable.
3. Prints the type and value of the variable after each assignment.
4. You'll also need to handle a scenario where you try to assign a nil value to the empty interface and observe its behavior.

Key Requirements:

• Use the interface{} type.
• Demonstrate assignment of various primitive types and a custom struct.
• Print both the type and value of the empty interface variable.
• Show how nil behaves with an empty interface.

Expected Behavior:

The program should clearly show that the interface{} variable can indeed hold values of different types and that its underlying type and value change accordingly. It should also correctly report the type and value of nil.

Important Considerations:

• When printing the type, use the %T format specifier with fmt.Printf.
• When printing the value, use the %v format specifier.

Examples

Example 1:

Input:
(No direct input, program logic defines the flow)

Output:
Value: 10, Type: int
Value: hello, Type: string
Value: true, Type: bool
Value: 3.14, Type: float64
Value: {Name:Alice Age:30}, Type: main.Person
Value: <nil>, Type: <nil>

Explanation: The program starts with an empty interface variable. It then sequentially assigns an integer, a string, a boolean, a float, and a custom struct to this variable. After each assignment, it prints the current value and its underlying type. Finally, it assigns nil and prints its type and value.

Constraints

• The program should be written entirely in Go.
• No external libraries beyond the standard fmt package are required.
• The solution should be clear and demonstrate the core concept effectively.

Notes

• The empty interface interface{} is Go's way of representing a value of any type. It's similar to void* in C/C++ but type-safe at runtime.
• When you assign a value to an interface{}, it internally stores both the value and its underlying type.
• Be mindful of how nil is represented when dealing with the empty interface.