Go Type Assertion Mastery

Go's type system is powerful, and understanding how to safely work with interfaces is crucial for building robust applications. Type assertion allows you to extract the underlying concrete value from an interface value when you know its specific type. This challenge will test your ability to implement and use type assertions effectively in Go.

Problem Description

Your task is to write a Go function that takes an interface{} as input and attempts to perform type assertions to determine the concrete type of the value stored within. The function should return the asserted value and a boolean indicating whether the assertion was successful.

Key Requirements:

• The function signature should be: func assertType(value interface{}) (interface{}, bool)
• The function should attempt to assert the input value to common Go types like int, string, and bool.
• If an assertion to int is successful, return the int value and true.
• If an assertion to string is successful, return the string value and true.
• If an assertion to bool is successful, return the bool value and true.
• If none of the above assertions are successful, return nil and false.
• Handle the case where the input interface{} itself might be nil.

Expected Behavior:

The function should gracefully handle different types of input and return the appropriate concrete value and success status.

Edge Cases:

• Input is nil.
• Input is an interface value that holds a type not explicitly checked (e.g., float64, a custom struct).

Examples

Example 1:

Input: 42 (an int)
Output: 42, true
Explanation: The input value is an int, so the type assertion to int succeeds. The function returns the int value and true.

Example 2:

Input: "Hello, Go!" (a string)
Output: "Hello, Go!", true
Explanation: The input value is a string, so the type assertion to string succeeds. The function returns the string value and true.

Example 3:

Input: true (a bool)
Output: true, true
Explanation: The input value is a bool, so the type assertion to bool succeeds. The function returns the bool value and true.

Example 4:

Input: 3.14 (a float64)
Output: nil, false
Explanation: The input value is a float64, which is not one of the types we are explicitly asserting for. Therefore, all assertions fail, and the function returns nil and false.

Example 5:

Input: nil
Output: nil, false
Explanation: The input interface value is nil. Type assertions on a nil interface will always fail, so the function returns nil and false.

Constraints

• The function should only attempt assertions for int, string, and bool.
• Input will be of type interface{}.

Notes

Remember that Go's type assertion syntax for checking success is value, ok := interfaceValue.(TargetType). This ok variable is crucial for determining if the assertion was valid. Consider the order in which you perform your assertions, although in this specific problem, the order doesn't strictly matter as long as you check for all required types.