Interface implementing

I don’t really understand why go’s interfaces are implemented implicitly. I think it is easier to see that a type implements a interface when I’m reading the type declaration, rather than reading it from the type usage in code.

But mainly, when I have a interface and then a type that implements that interface, changing the interface will result in error not when the type that should implement the interface is declared, but when it is used somewhere with that now incompatible interface.
Which I find more confusing than a keyword for explicit interface implementing.

I saw an argument that you can take a type from one library and a interface from another library and use them together. I don’t think this is a good idea at all. I find it very rare that two developers wrote interface and a type that have all the same functions with the exact same name and functionality. And again, if one of them decides that their type/interface function should be renamed/changed, my code breaks.

What is the reason for implicit interface implementing?

With implicit interfaces, a package author does not have to take care of, nor even know of, alternate implementations of their package API.

A user of a package, on the other hand, can define an interface and provide an alternate implementation without having to change the original package (that the user usually does not have write access to).

Some more explanations are in this /r/golang thread.