Go Generics: Why Can't I Assign `Props[Example]` to `Props[Generic]`?

Generic Type Argument Mismatch: Why Assignments Fail

In Go, attempting to assign a value of type Props[Example] to a variable of type Props[Generic] will result in an error. This is because, despite Example implementing the Generic interface, instantiating a generic type with different type arguments produces distinct named types.

Type Instantiation with Generics

When specifying a type argument for a generic type, whether in function arguments or return types, a new, distinct type is instantiated. For example:

func Problem() Props[Generic] {
    return ExampleProps
}

This line instantiates Props with the type argument Generic, resulting in Props[Generic]. Similarly, ExampleProps is instantiated with the type argument Example, resulting in Props[Example].

Type Incomparability and Assignment

As Props[Example] and Props[Generic] are two different named types, they cannot be assigned to each other, even if the types used as arguments (e.g., Example and Generic) satisfy an assignment condition like implementing an interface.

This concept applies similarly to generics instantiated with any. any is a static type, an alias for interface{}, and it does not match T or any particular type.

Addressing the Issue

To resolve the assignment error while maintaining flexibility, consider instantiating Props with a type parameter:

type Props[G Generic] struct{ Value G }

func Problem[T Generic](v T) Props[T] {
    return Props[T]{ Value: v }
}

This allows you to instantiate Props with a type argument that meets the necessary constraint and use the returned value as expected.

The above is the detailed content of Go Generics: Why Can't I Assign `Props[Example]` to `Props[Generic]`?. For more information, please follow other related articles on the PHP Chinese website!