Go's "duck typing" is basically Java-style interfaces that don't have to be explicitly declared: if a type has all the properties to fulfill an interface, it automatically fulfills it.

This sounds similar to duck typing, but it's significantly less powerful because you pass values into functions with a particular declared type, and you can only access methods available to the declared type of the value.

For example:

  interface MyInterface { Bar() }

  struct Foo {}

  func (this Foo) Bar()

  func (this Foo) Baz()

  func MyFunction(arg MyInterface) {
    arg.Bar() // Fine, because MyInterface has this method.
    arg.Baz() // Compiler error because MyInterface does not have this method.
  }

In this example, you could use reflection or the unsafe package to call arg.Baz() despite the fact that arg isn't guaranteed to have that method, but it takes some work and you're basically breaking the way the language is meant to be used.

This isn't a problem in Python or Ruby because they don't have a notion of declared type in function arguments -- the "type" is resolved at run-time by method lookup.