Given:
type MyInterface interface{
MyMethod() int
}
var im MyInterface
...
If I call:
switch t := im.(type) {
case:....
default:...
}
What is the actual type of the variable t when it is declared? To illustrate the question: If I wanted to write
var t //What type should I use?!
How would I declare t ?
For example In Delphi we have this structure:
TTypeInfo = record
Kind: TTypeKind;
Name: string;
{TypeData: TTypeData}
end;
I believe I am looking for something in GoLang that is akin to TTypeKind, which has potential values such as tkInteger, tkString etc.
In C++, we find the type_info class type, which also provides some of this functionality.
What type would I use for t in the var t... declaration? Is this even possible?
The type switch in Go is weird and special business. It’s not a generalization of another form that happens to be applied to types.
To my knowledge, you can’t write it using var (and I do recognize that you only mention the var form as illustration).
Within a case clause of the switch, t has the type specified in that case (see @Mue’s answer). Inside the default clause, it has im’s original type.
To answer your question, the t symbol in this case is weird and special, and only meaningful in the context of the switch. Its type is context-dependent. I hesitate to even call it a variable.
Edit, speculation:
I haven’t looked at the compiler but I suspect it deconstructs each case into a type assertion (cast), the result of which is a local variable within the scope of the case clause. As a syntactic convenience, you can refer to each using the t symbol.
In the following line:
switch t := im.(type) {
t is already declared & initialized with the value of the type, therefore you don't have to declare it again using var t.
It is simple and needs no declaring.
switch t := anyVar.(type) {
case ThisType:
// t is of type ThisType
case ThatType:
// t is of type ThatType
default:
// t has its original type.
}
And by the way, please no prefix I for an interface, that's no Go style. Typically you choose a subject matching to the verb(s) of the method(s). See
type Writer interface {
Write([]byte) (int, error)
}