TLDR: Why should I NOT the alias form `type ... = interface {...}` instead
of the standard `type ... interface {...}` for interface declarations?
The extended question:
The normal type definition for an interface in go would be `type TypeName
interface {...}`. This results in a new type, which is assignable to other
types of the similar interfacce, such that this is valid:
```
type I1 interface{ Foo() }
type I2 interface{ Foo() }
var _ I1 = I2(nil)
```
But these are different types, such that any function with one of these in
the signature can't be converted to a similar function with the other, such
that this is NOT valid:
```
var _ func(I1) = (func(I2))(nil)
```
Declare the types as aliases <https://yourbasic.org/golang/type-alias/>
however,
and the limitation dissapears:
```
type I1 interface{ Foo() }
type I2 interface{ Foo() }
var _ I1 = I2(nil) // still valid
var _ func(I1) = (func(I2))(nil) // now valid
```
A runnable example of the below using `http.ResponseWriter`:
- without alias <https://play.golang.org/p/dKdh80LNMt0>
- with alias <https://play.golang.org/p/sR5hB0ParA0>
My point being using aliases offers an advantage (more flexible assignment
and interface implementation) and to my knowledge no meaningful drawback.
So why not use it everywhere?
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/golang-nuts/d9595614-ce72-4602-8ead-67e9a1427181n%40googlegroups.com.
