i'm a new gopher and got really confused by variable types, if i'm defining a custom error
import (
"fmt"
"reflect"
)
// custom errors
type myError struct {
msg string
}
func (m *myError) Error() string {
return m.msg
}
func errorGen() error {
return &myError{"custom error"}
}
generate a new error and check the type of it
func main() {
e := errorGen()
fmt.Println(reflect.TypeOf(e).Kind()) // type = pointer
// first type assertion
_, ok := e.(error)
if ok {
fmt.Println("type assertion error") // type = error
}
// second type assertion
_, ok = e.(*myError)
if ok {
fmt.Println("type assertion *myError") // type = pointer
}
}
so in above code variable 'e' shows 2 types at the same time. What exactly is e's type? and why "error" is an interface and also can be used as return type?
thank you very much
You have to differentiate between the "static type" and the "dynamic type" of a variable.
Each and every variable in Go has exactly one static type. Some example:
a := 5 the static type of a is int and that is all to know about a.e in your code is error(because that is what errorGen returns).var b uint16 = 9.Now there are interface types in Go. error is such an interface type, see Peter's answer. Some variables will have error as their static type; your e is an example. Now, the whole purpose of a variable of interface type is to store values of various types which implement this interface. So a interface variable which is not nil somehow "contains" an other variable (actually a value). The type of this contained value can be any one which implements the interface. The type of the contained value is the "dynamic type". Type assertion let you extract values of this dynamic type.
The Go Programming Language Specification
The predeclared type error is defined as
type error interface { Error() string }It is the conventional interface for representing an error condition, with the nil value representing no error.
An interface type specifies a method set called its interface. A variable of interface type can store a value of any type with a method set that is any superset of the interface. Such a type is said to implement the interface.
e implements the predeclared interface type error.
// first type assertion
_, ok := e.(error)
if ok {
fmt.Println("type assertion error") // type = error
}
e's concrete type is a pointer to type myError.
// second type assertion
_, ok = e.(*myError)
if ok {
fmt.Println("type assertion *myError") // type = pointer
}
Both type assertions are true (ok is true).