3 ms·

No not using pointers would not solve the issue. The issue is that the specific error implementation type is part of the method signature. If you returned type

No not using pointers would not solve the issue. The issue is that the specific error implementation type is part of the method signature. If you returned type MyError instead of *MyError, then it would be impossible to return nil from the method because only pointers can be nil.

gregwebs 4y ago
I get that. But why define the Error method on a pointed receiver? In my experience almost all errors can be immutable particularly once you start using wrapping.
- gregwebs 4y ago
  Never mind- that doesn't actually make a difference. The solution in this case is to not re-use an existing error variable- but re-use of an error variable is common practice.
  - im-a-baby 4y ago
    Yea, the issue is that nil's in Go are typed. So `err == nil` is checking err against error's nil value, but the value stored in err is *MyError's nil value. package main import "fmt" type MyError struct{} func (m *MyError) Error() string { return "" } func main() { var err error = nil var myErr *MyError = nil fmt.Println(err == myErr) // this is false }
    - gregwebs 4y ago
      Comparing different types normally is a type error. But for interfaces the non-interface value will be converted to the type of the interface value. This conversion gives it a boxed dynamic type. This is different type than just assigning nil, which is the untyped nil, which sets the interface to its zero value. Normally one would not compare two interface values, so this issue really comes up when comparing an interface to nil. If Go had proper option types then this issue would go away. https://go101.org/article/nil.html https://go101.org/article/nil.html package main import "fmt" type Err1 struct{} func (m Err1) Error() string { return "" } type Err2 struct{} func (m Err2) Error() string { return "" } func main() { var err error = nil var myErr1 *Err1 = nil var myErr2 *Err2 = nil fmt.Println(err == myErr1) // this is false fmt.Println(err == myErr2) // this is false fmt.Println((error)(myErr1) == (error)(myErr2)) // this is false. requires the cast to do the comparison }

gregwebs 4y ago

I get that. But why define the Error method on a pointed receiver? In my experience almost all errors can be immutable particularly once you start using wrapping.

gregwebs 4y ago
Never mind- that doesn't actually make a difference. The solution in this case is to not re-use an existing error variable- but re-use of an error variable is common practice.
- im-a-baby 4y ago
  Yea, the issue is that nil's in Go are typed. So `err == nil` is checking err against error's nil value, but the value stored in err is *MyError's nil value. package main import "fmt" type MyError struct{} func (m *MyError) Error() string { return "" } func main() { var err error = nil var myErr *MyError = nil fmt.Println(err == myErr) // this is false }
  - gregwebs 4y ago
    Comparing different types normally is a type error. But for interfaces the non-interface value will be converted to the type of the interface value. This conversion gives it a boxed dynamic type. This is different type than just assigning nil, which is the untyped nil, which sets the interface to its zero value. Normally one would not compare two interface values, so this issue really comes up when comparing an interface to nil. If Go had proper option types then this issue would go away. https://go101.org/article/nil.html https://go101.org/article/nil.html package main import "fmt" type Err1 struct{} func (m Err1) Error() string { return "" } type Err2 struct{} func (m Err2) Error() string { return "" } func main() { var err error = nil var myErr1 *Err1 = nil var myErr2 *Err2 = nil fmt.Println(err == myErr1) // this is false fmt.Println(err == myErr2) // this is false fmt.Println((error)(myErr1) == (error)(myErr2)) // this is false. requires the cast to do the comparison }