Go demonstrates basically the concept of interfaces I have in mind: anything that satisfies the interface can be used as it, without having to be specifically declared as implementing it. And there are languages with good type interference, like Haskell. So that makes me wonder: what about a language where the interfaces don't even have to be declared?
Even in Haskell, typeclasses are defined somewhere. And in fact, since Haskell doesn't have method namespacing, and doesn't normally allow overloading a top-level name with different type signatures, you have to use a typeclass to get polymorphism - it's the only way a function can be allowed to take two unrelated types.
Here's a simple class in Haskell:
class YesNo a where yesno :: a -> Bool instance YesNo Int where yesno 0 = False yesno _ = True instance YesNo [a] where yesno  = False yesno _ = True main :: IO () main = return ()
What if I didn't need to define the class, only the two
yesno verisons, like so?
yesno :: Int -> Bool yesno x = x /= 0 yesno :: [a] -> Bool yesno x = not $ null x
That isn't allowed in current Haskell, but what if it was? I can't think of any reason why there couldn't be a language that allowed this. Essentially, one where interfaces are not only implemented automatically, but defined automatically.