Go Type Inference Playground

Type inference is a powerful feature in Go that allows the compiler to deduce the type of a variable based on its initialization. This reduces boilerplate code and improves readability. This challenge asks you to build a simple program that demonstrates and tests Go's type inference capabilities, focusing on various scenarios and edge cases.

Problem Description

You are tasked with creating a Go program that defines several variables and initializes them with different values. The program should then print the inferred type of each variable. The goal is to verify that Go's type inference system correctly determines the type of each variable based on its assigned value. You should handle various data types including integers, floats, strings, booleans, and potentially more complex types like slices or maps. The program should be robust and handle potential errors gracefully.

Key Requirements:

• Define at least 10 variables with different initialization values.
• Use only type inference (i.e., var variableName = value). Do not explicitly declare the type.
• Use the reflect package to determine the runtime type of each variable.
• Print the variable name and its inferred type in a clear and readable format.
• Handle potential errors during type reflection.

Expected Behavior:

The program should output the name of each variable followed by its inferred type, as determined by the Go compiler. The output should be formatted consistently and easy to understand. For example:

variable1: int
variable2: float64
variable3: string
...

Edge Cases to Consider:

• Zero values: How does Go infer the type of a variable initialized to zero (e.g., var x = 0)?
• Empty strings: What type is inferred for an empty string (var s = "")?
• Nil values: How does Go handle variables initialized to nil (e.g., var m = nil)? Consider slices, maps, and pointers.
• Mixed types: If a variable is later assigned a different type, how does the compiler handle it? (This is less about inference and more about type conversion, but good to consider).
• Constants: How does Go infer the type of a variable initialized with a constant?

Examples

Example 1:

Input:
var x = 10
var y = 3.14
var z = "hello"
var a = true
var b = nil

Output:

x: int
y: float64
z: string
a: bool
b: <nil>

Explanation: The compiler infers the types of x, y, z, and a based on their initial values. b is initialized to nil, which represents a nil pointer or nil slice/map depending on the context.

Example 2:

Input:
var i = 0
var s = ""
var f = 0.0

Output:

i: int
s: string
f: float64

Explanation: Zero values are inferred as their respective default types (int for 0, string for "", float64 for 0.0).

Example 3:

Input:
var slice = []int{1, 2, 3}
var map1 = map[string]int{"a": 1, "b": 2}

Output:

slice: []int
map1: map[string]int

Explanation: Slices and maps are inferred based on their literal initialization.

Constraints

• The program must be written in Go.
• The program must use only type inference for variable declarations.
• The program must use the reflect package to determine the runtime type.
• The program must handle potential errors gracefully.
• The program should be reasonably efficient (avoid unnecessary allocations or computations).
• The program should define at least 10 variables to demonstrate a variety of type inference scenarios.

Notes

• The reflect.TypeOf() function is your primary tool for determining the runtime type of a variable.
• Consider using a loop to iterate through the variables and print their types.
• Pay close attention to the edge cases mentioned in the problem description.
• Think about how to format the output in a clear and readable way.
• This challenge is designed to test your understanding of Go's type inference system and your ability to use the reflect package. Don't try to change the inference; just observe and report it.